Java基础-笔记一(2023.12.03-12.14)

学习内容：

Java基础语法

注：我已经学习过很长一段时间了，这次只是从头开始，跟着菜鸟编程过一遍已经学过的知识并借此熟悉Markdown，有可能会忽略一些自己觉得比较简单的部分。
【初学者不能看我的，大佬不用看我的】
有时候会把一些单词的英文加上。

菜鸟编程原地址：https://www.runoob.com/java/java-tutorial.html

---

一、基本语法

1. Java是大小写敏感的
2. 类名的首字母大写，若类名由多个独立单词组成，则各个单词的首字母大写，如：MyJavaStudyNotes
3. 方法名以小写字母开头，若类名由多个独立单词组成，则各个单词的首字母大写，如：takeNotes
4. 源文件名必须与类名相同

二、标识符【类名 / 变量名 / 方法名】

1. 字母、美元符号（$）或下划线（_）作为首字符
2. 首字符之后可以加上数字，四种字符任意组合
3. 关键字不能用

关于什么是关键字，可以自行搜索一下，这是菜鸟编程的网址：https://www.runoob.com/java/java-basic-syntax.html

三、修饰符(modifier)

1. 访问控制修饰符(access modifier)：
   default: 默认
   public: 被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
   protected:
   private: 类和接口不能声明为private，该类型变量只能通过类中公共的getter方法被外部类访问。【隐藏类的实现细节并保护类的数据】

修饰符	当前类	同一包内	子孙类（同一包）	子孙类（不同包）	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

子类的权限 ≥ 父类的权限：
public＞protected > private

2. 非访问控制修饰符：

final: 类 + 方法 + 变量 【常量不可修改】

父类中的 final 方法可以被子类继承，但是不能被子类重写。
final 类不能被继承，没有类能够继承 final 类的任何特性。

static: 类方法 + 类变量

类型	介绍
静态变量	static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法	static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

//偷懒一段，饿了，急着出去吃夜宵，直接复制的，冒昧了
//对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }
 
   private static void addInstance() {
      numInstances++;
   }
 
   InstanceCounter() {
      InstanceCounter.addInstance();
   }
 
   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
          }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}

synchronized: 线程的编程

synchronized 关键字声明的方法同一时间只能被一个线程访问。
synchronized 修饰符可以应用于四个访问修饰符。

transient：

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

volatile: 线程的编程

abstract: 创建抽象类 + 抽象方法

这俩先等等

四、Java运算符

加（+）减（-）乘（*）除（/）取余（%）自增（++）自减（–）
大于（>）小于（<）等于（==）不等于（!=）小于等于（<=）大于等于（>=）
逻辑与（&&）逻辑或（||）逻辑非（!）

位运算符：

& ：对位“与”
| ：对位“或”
<< ：左移两位
>> ：右移两位，左侧不补，位数少了就少了
~ ：按位取反
^：对位是否相同
>>> ：右移，左侧空位补零

所有的运算符加个=
例子：a /= 2表示：a = a / 2

三位运算符：“?: ”

variable x = (expression) ? value if true : value if false
如果 a 等于 1 成立，则设置 b 为 20，否则为 30
b = (a == 1) ? 20 : 30;

incetanceof 运算符：

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）
( Object reference variable ) instanceof  (class/interface type)
如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

五、Java Number & Math类

Java为每一个内置数据类型提供了对应的包装类，这些包装类都是抽象类Number的子类。

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。

// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';
 
// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');

java.lang包→Number类：

Byte, Short, Integer, Long, Float, Double

Java Math类

方法	描述
xxxValue()	将Number对象转换为xxx数据类型的值，返回
compareTo()	将Number对象与参数比较
equeals()	判断Number对象是否与参数相等
valueOf	返回一个Number对象指定的数据类型
toString()	xxx转为字符串
parseInt()	字符串转为 int
abs()	取绝对值
ceil()	返回大于等于参数的最小整数，返回类型为双精度浮点型double
float()	返回小于等于参数的最小整数
rint()	返回与参数最接近的整数，返回类型为double
round()	四舍五入
atan2()	将笛卡尔坐标转换为极坐标，并返回极坐标的角度值
toDegrees()	将参数转换为角度
toRadians()	将参数转换为弧度
random()	返回一个随机数
其它	max(), min(), exp(), log(),pow(),sqrt(),sin(),cos(), tan(), asin(), acos(), atan()

六、Java Character类 & 转义字符 & String 类 & StringBuffer & StringBuilder

（一）Character方法

方法	描述
isLetter()	判断是否字母
isDigit()	判断是否数字字符
isWhitespace()	判断是否空白字符
isUpperCase()	判断是否大写
isLowerCase()	判断是否小写
toUpperCase()	转为字母的大写
toLowerCase()	转换为字母的小写
toString	返回字符的字符串形式

（二）Java String 类

1. 创建格式化字符串：
   format()返回一个String对象而不是PrintStream对象；
   format()创建可复用的格式化字符串，而不仅仅用于一次打印输出。

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

附上Java String 类的API文档：https://www.runoob.com/manual/jdk11api/java.base/java/lang/String.html

（三）StringBuilder类

（四）StringBuffer类

七、Java数组

1. 创建数组：
   dataType[] arrayRefVar = new dataType[arraySize];
java dataType[] arrayRefVar = {value0, value1, ..., valuek};

String[][] str = new String[3][4]; //二维数组

2. for-each：

for(type element: array)
{
    System.out.println(element);
}

3. Arrays 类

方法	描述
public static int binarySearch(Object[] a, Object key)	用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)
public static boolean equals(long[] a, long[] a2)	如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
public static void fill(int[] a, int val)	将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
public static void sort(Object[] a)	对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）

八、对象和类 & Java变量

1. 对象：一个实例，例如”一个学生“是一个对象
2. 类：对象的行为和属性
3. 局部变量：使用前先初始化；是在栈上分配的
4. 类变量（静态成员变量）
   驼峰命名：MAX_COUNT

此处引用一段菜鸟编程的代码：

public class Counter {
    private static int count = 0;
    
    public Counter() {
        count++;
    }
    
    public static int getCount() {
        return count;
    }
    
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
        System.out.println("目前为止创建的对象数: " + Counter.getCount());
    }
}

输出：

目前为止创建的对象数: 3

5. 成员变量（非静态变量&实例变量）

成员变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObjectReference.VariableName。
成员变量的声明语法为：accessModifier type variableName;

与局部变量不同，成员变量的值在创建对象时被分配，即使未对其初始化，它们也会被赋予默认值，例如 int 类型的变量默认值为 0，boolean 类型的变量默认值为 false。
成员变量可以通过对象访问，也可以通过类名访问（如果它们是静态成员变量）。如果没有显式初始化成员变量，则它们将被赋予默认值。可以在构造函数或其他方法中初始化成员变量，或者通过对象或类名访问它们并设置它们的值。

6. 参数变量

在调用方法时，我们必须为参数变量传递值，这些值可以是常量、变量或表达式。
方法参数变量的值传递方式有两种：值传递和引用传递。

值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。Java 中的基本数据类型都采用值传递方式传递参数变量的值。
引用传递：在方法调用时，传递的是实际参数的引用（即内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。Java 中的对象类型采用引用传递方式传递参数变量的值。

package object_oriented;

public class Student{
    String name;
    int age;
    int studentID;
    //类中，方法体外：以上三个为<成员变量>或<实例变量>
    //如果不明确初始化，实例变量会被赋予默认值
    public static Integer grade = 100;
    //<静态成员变量>，随着类的加载而存在于方法区中:<类变量>
    //该类的所有实例共享同一类变量的值

    //下面这个是构造方法，方法名与类名相同
    //一个类可以有多个构造方法
    public Student(String name){
        System.out.println("The student's name is: " + name);
    }

	/*假如有多个构造方法
	public Student(String name, int age){
	System.out.println("The student's name and age are: " + name + age);
	}
	*/

    //set()，get()
    //此处第一个int age的age为参数变量
    public void setAge( int age ){
        this.age = age;
    }

    public int getAge( ){
        System.out.println("学生的年龄为 : " + age );
        return age;
    }

    //以下两个为Studengt类的方法
    void eat(){
    }

    void study(){
        String math = "1 + 1 = 2";
        //方法、构造方法或者语句块中定义的变量：<局部变量>
        //局部变量在方法结束后自动销毁
        System.out.println(math);
    }

    //主函数
    public static void main(String[] args){
        //创建对象
        Student tom = new Student("tom");
        tom.setAge(16);
        tom.getAge();
        System.out.println("tom的年龄为： " + tom.age);
    }

}

九、 Java 方法

System.out.println();
调用系统类System中的标准输出对象out中的方法println()。

方法的命名规则
1.第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写。例如：addPerson。
2.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。
  典型模式：test<MethodUnderTest>_<state>
  例如 testPop_emptyStack。

方法的定义：

public static     void    main  (String[] args)
   修饰符       返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法的重载：

创建另一个有相同名字但是参数不同的方法：

如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；
如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

命令行参数：

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
命令行参数是在执行程序时候紧跟在程序名字后面的信息。
$ javac CommandLine.java
$ java CommandLine this is a command line 200 -100

可变参数：

一个方法只能只能指定一个可变参数，且必须是方法的最后一个参数。
public static void Max(int number1, double… numbers)

十、基本数据类型

（一）六种数字（四整数，二浮点），一字符，一布尔[表格中的前六种]

数据类型	位数	默认值
byte	8位	0
int【整数默认类型】	32位	0
long	64位	0L
float	32位	0.0f
double【小数默认类型】	64位	0.0d
boolean	1位	false
char	16位Unicode字符	‘U0000’（其实输出是空）
String(or any other object)	—	null(一个常量)

以上所有数据类型（除了boolean）的最大(小)值均可通过“数据类型.MAX_VALUE"（数据类型.MIN_VALUE）获取
例如：Double.MIN_VALUE, Character.MAX_VALUE

byte,int,long,short都可以用十进制，16进制，8进制表示，例如：

int decimal = 100;//十进制
int octal = 0144;//0开头，8进制
int hexa = 0x64;//0x开头，16进制

（二）转义字符序列【直接截自菜鸟编程】

（三）数据类型转换

1. 自动类型转换：转换前的数据类型位数<转换后的数据类型位数
   例如：short（16位）< int（32位），float（32位）< double（64位）
2. 强制类型转换：数据类型必须兼容

int i = 123;
byte b = (byte)i;//强制转换为byte

十一、一些基础

注释(annotation)

1. 单行注释 //
2. 多行注释 /* */
3. 文档注释 /** */

文档注释的格式通常包含一些特定的标签，如 @param 用于描述方法参数，@return 用于描述返回值，@throws 用于描述可能抛出的异常等等，这些标签有助于生成清晰的API文档，以便其他开发者能够更好地理解和使用你的代码。

循环结构

1. while( )
2. do{ }while( )
3. for(初始值；判断语句；更新初始值){ }
   for(声明新的局部变量，该变量的类型必须和数组元素的类型匹配 : 要访问的数组名，或者是返回值为数组的方法) { //代码句子 }
4. continue(): 跳过下面的重新循环
5. break: 跳过下面的出循环

条件语句

1. if( )else{ }
2. if( )else{ }if( )

switch case

switch(expression){
	//value是字符串常量或者字面量
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

Java中源文件声明规则，以及java包，import关键字的使用

不是很明白源文件声明规则