一些关于速成的看法

by 骆亚非

一、一些有关知识

1、文件及后缀

我们（码农）可编写的Java程序为.java的后缀。
电脑会编译我们写的Java代码生成字节码（一种二进制的文件）程序（.class）且不同的软件编译的字节码文件相同（好像只有Java的程序写出来编成二进制叫这个）。

2、虚拟机（JVM）

用C++写成的运行Java的抽象计算机（C++好像更高级）字节码要经过Java虚拟机转译成系统的机器码后才能运行。所以，运行Java必须使用对对应的JVM。

3、面向过程与面向对象

面向过程PO（Procedure Oriented） ：

重在完成事情的每个步骤，比如洗衣机的加水、转动等，但只要符合要求不论是衣服还是Mate 60都会被焕然一新，无差别清洗。

面向对象OO（Object Oriented） ：

重视完成任务的对象，会赋予对象一定的属性（比如神秘学姐的身高、体重、性别就是她的独特属性）及方法（任务）（比如赋予神秘学姐吃麦乐鸡的方法，那就只能他她去吃，别人不准吃）
面向对象编程的特点：封装、继承、多态（都没懂，help sir,hlep）

二、基本语法

1.注释

第一种

//注释单行

第二种

/*
注释多行
我说三句话
这是第二句
我说完了
*/

第三种

/**
*注释一段
*可以被javadoc命令（这是啥？）解析提取
*可以生成到帮助文档中去
*/

2.标识符

1）0~9、$、_、Unicode字符（）组成
eg:

public class UnicodeTry {
    public static void main(String[] args) {
        char checkMark = '\u2713';
        System.out.println("勾号：" + checkMark);
    }
}
//gpt上改写的，有错请指正

2）没有空格存在，可以这样命名（eg：ShuoDao）
3）第一个字符不为数字
4）不能用保留字关键字（已命名的标识符也是关键字）
5）命名后要方便理解使用
附：

6）命名方法
驼峰命名(Camel-Case)法
1)类名、接口名：首字母大写，后面每个单词首字母大写
2)变量名、方法名：首字母小写，后面每个单词首字母大写
3)常量名：全部大写，单词与单词之间用下划线连接

3、变量

指代某条数据
必须先给提一句（声明），再开始用
（以下不明白）
1.1）局部变量：在方法体中声明。
1.2）实例（成员）变量：在类中但在方法体外声明的变量，成员变量定义了类的属性。
1.3）静态变量：由所有的类实例共享。对于类的所有对象，只存在一个静态变量实体。随着类的加载而加载，随着类的销毁而销毁。有默认值，不必初始化。

2)声明变量

int age;            // 声明一个整数变量
double score;       // 声明一个双精度浮点数变量
char grade;         // 声明一个字符变量
String name;        // 声明一个字符串变量
boolean passed;  // 声明一个布尔变量  true/false

数据类型

补充
数字 : byte，short,int ,long
浮点 : float,double

4.运算符

1）算数运算符
常见的我略了，讲的实在整理不完太多了

% 取余数

++自增
P.S.
a++，先返回a，再加上1
++啊，先加1，再返回a
（return不知道咋翻译好）
--自减
（自增自减会不会用a=a+1/1+a和a=a-1/-1+a,表示起来方便一点？）

2）关系运算符
常见的我略了，讲的实在整理不完太多了
（I）一般实际数值满足关系运算符所表示的那就为真
（II）！=，表示不相等
3）逻辑运算符
&&类似中文的“且”，类似于数学手写的逻辑符号⋀，写作A&&B
||类似于中文的“或”，类似于数学手写的逻辑符号⋁,写作A||B
！，表示正误反转，写作!(A||B)
4)赋值运算符
大概就像是把正常的加减等符号挪到了等号另一侧，省去了重复出现的字母（，让人看起来更别扭）
C + = A等价于C = C + A
C - = A等价于C = C - A
C = A等价于C = C A
C / = A，C 与 A 同类型时等价于 C = C / A
C％= A等价于C = C％A （注：意为Mod）
C << = 2等价于C = C << 2
eg：

public class Tryiing{
pubic static void main(String[] args){
int a=2;
a<<=2;
System.out.println(a);
}
}
//2在二进制中为10，左移两位1000换算一下十进制中为8

C＆= 2等价于C = C＆2（二进制中只有当两个位都为1时，结果的对应位才为1，否则为0。）
C ^ = 2等价于C = C ^ 2（二进制中只有当两个位不相同时，结果才为1，否则结果为0。）
C | = 2等价于C = C | 2（二进制中只要两个位中至少有一个为1，结果就为1，否则结果为0。）
5)Lambda表达式
留白

5.控制语句

1）条件
5.1.1 if
5.1.1.1

// if（condition）{
// 当条件为真时执行的代码
// }

以下是一个很好的例子

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        String a="郭苏睿";
        Scanner scanner = new Scanner(System.in);
        String inputText=scanner.nextLine();
        if (inputText.equals(a) ){System.out.println(inputText+"你真是牛蛙");
    }
   else System.out.println(inputText+"还在成为牛蛙的路上");
}}

5.1.1.2

if (condition) {
    // 当条件为真时执行的代码块
} else {
    // 当条件为假时执行的代码块
}

5.1.1.3

if (condition1) {
    // 当条件1为真时执行的代码块
} else if (condition2) {
    // 当条件2为真时执行的代码块
} else if ( condition3) {
    // 当条件1和条件2都为假时执行的代码块
}

个人的一些观点:

1. if语句，在各种可执行的各个语句执行的条件中优先选择靠前一种来执行。
2. 不论有多少个else if要是全不满足，就执行最后一条。

1.2 switch (这个语句不太明白，放在这里尽量使笔记显得完整（不是凑字数)

switch (表达式) {
    case 值1:
        // 当表达式的值等于值1时执行的代码
        break;
    case 值2:
        // 当表达式的值等于值2时执行的代码
        break;
    case 值3:
        // 当表达式的值等于值3时执行的代码
        break;
    // 可以有更多的 case 分支
    default:
        // 当表达式的值与所有的 case 值都不匹配时执行的代码
        break;
}

• 另一种 switch

  //此类形式不需要break
  switch (表达式) {
  case 值1 -> expression1;
  case 值2 -> {
                  expression2;
                  expression3;
      }
  case 值3 -> expression4;
  default -> expression0;
  }

  switch 语句中的表达式可以是整数类型（byte、short、int 或 char）及其包装类型（Byte、Short、Integer、Character）、枚举类型或字符串类型（从 Java 7 开始支持）。

case 分支用于指定当表达式的值与某个值相等时要执行的代码块。每个 case 分支后面必须使用 break 语句来跳出 switch 语句，否则程序将会继续执行后续的 case 分支代码。如果没有匹配的 case 分支，可以使用 default 分支来执行默认的代码块。

需要注意的是，switch 语句只能对某个表达式的值进行匹配，而不能用于范围判断或布尔表达式。每个 case 分支中的值必须是常量或字面量，而不能是变量或表达式。
（以上摘自讲义）
2）循环
2.1 for

for(intialization;condition;update){
//循环体代码
}

/*中文解释
*for(初始条件;循环条件;循环更新变量的操作){
//需要循环时要执行的语句
}

2.2另一种for

for (elementDataType elementVariable : collection) {
    // 循环体代码
}

elementDataType=集合元素数据类型
elementVariable =每次循环迭代时用于表示当前元素的变量名
collection =要遍历的数组或集合
执行过程：
①依次取出集合中的每个元素，并将其赋值给 elementVariable。
②执行循环体内的代码。
③回到第 1 步，继续取出下一个元素，重复执行上述步骤。
④当集合中的所有元素都被遍历完毕后，循环终止。
2.3while

while (condition) {
    // 循环体代码
}

循环体中的代码只有condition为真时执行。

要有能false的情况，否则无限循环
2.4do-while

do {
    // 循环体代码
} while (condition);

P.S.至少执行一次。
要有能false的情况，否则无限循环
(可以联系高中数学的流程图)

6. 方法

1）静态方法
可以通过类名称来调用，且只能引用金泰变量或局部变量。
2）非静态方法
调用必须先有一个实例，通过实例来调用
这部分还举不出例子

public class Calculator {
    private double memoryA;//私有成员变量，无法以Calculator.memoryA的形式获取
    private double memoryB;//成员变量
    public static double PI = 3.14159;//Math.PI

    //构造方法（构造器），起到初始化的作用
        //是用于初始化对象的特殊方法。它们具有与类相同的名称，并且没有返回值。当创建对象时，构造函数用于为对象分配内存并设置初始状态。
    public Calculator(double initialValueA, double initialValueB) {
        this.memoryA = initialValueA;
        this.memoryB = initialValueB;
    }

    //空参构造器，不存在自定义构造器时则默认存在
    public Calculator() {
        this.memoryA = 0;
        this.memoryB = 0;
    }

    //求和的非静态方法
    public double add() {
        double temp = memoryA + memoryB;
        memoryA = temp;
        return temp;
    }

    //求最大公约数的静态方法
    public static int gcd(int num1, int num2) {
        while (num1 != num2) {
            if (num1 > num2) {
                num1 = num1 - num2;
            } else {
                num2 = num2 - num1;
            }
        }
        return num1;
    }

    //获取memoryA
    public double getMemoryA() {
        return memoryA;
    }

    //设置memoryA的值
    public void setMemoryA(double memoryA) {
        this.memoryA = memoryA;
    }

    //获取memoryB
    public double getMemoryB() {
        return memoryB;
    }

    //设置memoryB的值
    public void setMemoryB(double memoryB) {
        this.memoryB = memoryB;
    }
}

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();

                //调用静态方法
        int a = Calculator.gcd(num1,num2);
        System.out.println(a);
        //System.out.println(Calculator.gcd(328,256));

                //直接输出静态值
                System.out.println(Calculator.PI);

                //创建对象myCalculator
                Calculator myCalculator = new Calculator(10, 20);
        myCalculator.add();
        System.out.println("这是memoryA: " + myCalculator.getMemoryA());
        System.out.println("这是加法结果: " + myCalculator.add());
                myCalculator.setMemoryA(10);
        System.out.println("这是新的memoryA: " + myCalculator.getMemoryA());

                //创建另一个新的对象anotherCalculator
                Calculator anotherCalculator = new Calculator(-30, -40);
        anotherCalculator.add();
        System.out.println("这是你的memoryA: " + anotherCalculator.getMemoryA());
        System.out.println("这是你的加法结果: " + anotherCalculator.add());
        anotherCalculator.setMemoryA(100);
        System.out.println("这是你新的memoryA: " + anotherCalculator.getMemoryA());
    }
}

7. 类和对象

作为一门OOP（Object-Oriented Programming）的编程语言很有必要了解（虽然明白不了一点

• 对象（Object）：我没有抽象于现实生活中的事物及概念，对象可以具有状态（属性）和行为（方法）。
• 类（class）：一些对象的集合，定义了对象的属性和方法。类是用于创建对象的模型，它包括数据成员和方法。

• 封装（Encapsulation）：把一些类打包起来。通过使用私有（private）访问修饰符来实现。（不大会用）

  public class Car {
  // 属性
  String brand;
  int year;
  
  // 方法
  void start() {
      System.out.println("The car is starting.");
  }
  
  void stop() {
      System.out.println("The car is stopping.");
     }
  }

  8. 数组

  一种对象
  8.1 定义数组

• 数组有属性，eg：长度。
• 数组长度不可改变。
• 定义多维数组，第一维数组的大小必须初始化，其他的不必初始化。
• But使用时必须先对要使用的其他维度的数组进行大小初始化才可以赋值。
  （大概能赋值一下就赋值吧。）

  int[]roommate=new int[4]

  还是抄写一下讲义来暂且使笔记完整

  //定义可以容纳10个整数的数组
  //方法一：
  int[] scores=new int[10];
  int scores[]=new int[10];//可读性差
  //方法二：
  int[] scores;
  scores=new int[10];
  //方法三：
  int[] scores={99,98,99,97,96,92,93,94,98,99};
  //多维数组
  int[][] a=new int[2][3];
  int[][] a= {{4, 5, 6},{1, 2, 3}};
  //低维可以不等长
  int[][] a = {{1, 2, 3}, {4,5}, {6}};
  //可以逐级创建：
  int[][] v = new int[1][];
  v[0] = new int[2];
  int[] arr=new int[] {1,2,3};

  8.2 for-each

  import java.util.Scanner;
  public class Main {
  public static void main(String[] args) {
      int[] roommate = new int[4];
      Scanner scanner = new Scanner(System.in);
      //String inputText = scanner.nextLine(System.in);
      System.out.println("请输入你和舍友的编号：");
      for (int x = 0; x < roommate.length; x += 1) {
          roommate[x] = scanner.nextInt();
      }
      System.out.println("Hello world!");
  }
  }

  举栗子还不如看讲义，实在太差了

  //定义可以容纳10个整数的数组
  //方法一：
  int[] scores=new int[10];
  int scores[]=new int[10];//可读性差
  //方法二：
  int[] scores;
  scores=new int[10];
  //方法三：
  int[] scores={99,98,99,97,96,92,93,94,98,99};
  //多维数组
  int[][] a=new int[2][3];
  int[][] a= {{4, 5, 6},{1, 2, 3}};
  //低维可以不等长
  int[][] a = {{1, 2, 3}, {4,5}, {6}};
  //可以逐级创建：
  int[][] v = new int[1][];
  v[0] = new int[2];
  int[] arr=new int[] {1,2,3};

  来看官方举栗子：

  int[] values={1,2,3};
  for (int value : values){
  value++;
  System.out.print(value );// 2 3 4
  }
  for (int value : values){
  System.out.print(value );// 1 2 3
  }

  8.3 可变长度参数表
  不懂
  8.4 二维数组
  不懂

  9. 继承

  9.1 继承（Inheritance）：
  继承是一种机制，允许一个类（子类/派生类）继承另一个类（父类/基类）的属性和方法。子类可以继承父类的成员，然后扩展或修改它们。
  （简单点，子承父命）
  java中允许“多层”继承，但不允许“多重”继承（儿砸多了争家产，bushi）
  9.2 修饰符

  变量和属性是有区别的：

变量是方法体中定义的，我们称为临时变量。
属性是类体中定义的。
1.而权限标示符只用于修饰属性和方法。不修饰变量。
2.方法中定义的临时变量在方法调用完成之后就不存在了，不需要用修饰符定义！
(不懂)

public class StringTest1{
static int getStringLength(){
private String s="Hello Alibaba";//此处报错！！！不能使用private修饰符！！！
int l=s.length();
return l;
 }
public static void main(String[] args){
System.out.println(StringTest1.getStringLength());
 }
}

9.3 重写方法/方法覆盖
1.子类中方法名、参数列表与父类中的方法名、参数列表一样时发生重写（财产继承）
2.返回值类型必须一致（新版本：返回值类型必须小于或者等于父类方法的返回值类型，可以类型转换 ）
3.子类方法访问权限＞=被覆盖的父类方法
4.子类不能重写父类中用final修饰的方法（说了不能传后代了，就是不能传）
5.子类不能重写父类的构造方法（不改父之道，可谓孝矣）
6.子类无法继承父类的构造函数（自己创业，不能吃老本）

方法重载（overloading）（还没用过）：
参数个数、类型或顺序不同，方法名相同（返回值类型可以不同）
java中方法的重写(overriding)和重载(overloading)是多态性的不同表现
7.父类被重写后，子类使用super调用的是父类的方法（被重写前的），其他情况下，直接调用被重写的方法，调用的就是子类中的方法。
8.java不支持super.super的用法
9.关键字final定义的方法，可以在同一个类中有重载（overloading）方法。（被继承后不能重写）
10.子类和父类的方法必须都是实例方法才会实现重写，若父类是静态方法，子类是实例方法或者相反都会报错，若父类和子类都是静态方法，那么子类会隐藏父类的静态方法，而不是覆盖。

10. 多态

（不懂）
多态是一种机制，允许不同的对象以相同的方式响应方法调用。多态通常涉及方法的覆盖（Override）和接口的实现（Implement）。它有助于实现代码的灵活性和可扩展性。

javaCopy code
interface Shape {
    void draw();
}

class Circle implements Shape {
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

class Rectangle implements Shape {
    void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

以下没讲，只为了完整

11.异常

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

import java.io.*;
public class ExcepTest{
   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

1)分类

• 错误catch无意义，无法修复
• exception
  • checked exception 强制处理异常 （非运行时异常）
    • ClassNotFoundException
    • NoSuchMethodException
    • IllegalAccessException
  • unchecked exception 非强制处理异常 （运行时异常）
    • NullPointerException
    • IndexOutOfBoundsException
    • ArithmeticException
    • StringIndexOutofBoundsException
    • NumberFormatException
    • ClassCastException 强制类型转换

2.处理程序中的异常，可以使用 try-catch 语句

• 一个 try 块后跟一个或多个 catch 子句
• 当 try 块中发生异常时，处理会立即跳转到与异常类型匹配的第一个 catch 子句
• try 语句可以有一个可选的 finally 子句，该子句始终执行
• 如果未生成异常，则在 try 块中的语句完成后执行 finally 子句中的语句
• 如果生成异常，则 finally 子句中的语句将在相应 catch 子句中的语句完成后执行

结论：finally中的语句无论如何都会被执行，即使之前有return语句，也要先finally，再return。 例外是System.exit();

写在后面：
前面搞懂的一些添加了或者写过一点点代码，后面没太明白+时间有点赶，没有实践。（下次不躺了）
这份笔记在日后还会完善。

2281612947