java 入门笔记

变量

1. java中声明的局部变量(声明在方法，if, while, for)变量必须初始化，未经过初始化的变量直接使用会编译失败
2. 声明的成员变量作用域是整个类，并且可以不初始化，若没有初始赋值，系统会为它分配一个默认值，每一种数据类型都有默认值，int类型默认值是0。

常量(静态常量、成员常量和局部常量)

public class HelloWorld {
    // 静态常量，替代保留字const
    public static final double PI = 3.14;
    // 声明成员常量
    final int y = 10; 
    public static void main(String[] args) {
        // 声明局部常量
        final double x = 3.3;
    }
}

public static修饰的常量作用域是全局的，不需要创建对象就可以访问它，在类外部访问形式：HelloWorld. PI

命名规范

1. 包名：包名是全小写字母，中间可以由点分隔开。作为命名空间，包名应该具有唯一性，推荐采用公司或组织域名的倒置，如com.apple.quicktime.v2。但Java核心库包名不采用域名的倒置命名，如java.awt.event
2. 类和接口名：采用大驼峰法，如SplitViewController。
3. 文件名：采用大驼峰法，如BlockOperation.java。
4. 变量：采用小驼峰法，如studentNumber。
5. 常量名：全大写，如果是由多个单词构成，可以用下划线隔开，如YEAR和WEEK_OF_MONTH。
6. 方法名：采用小驼峰法，如balanceAccount、isButtonPressed等。

注释规范

1. 单行注释： //
2. 多行注释： /.../
3. 文档注释： /*.../ 这种注释内容能够生成API帮助文档
4. 生成文档命令： javadoc -d apidoc Hello.java -d参数指明要生成文档的目录

数据类型分为：基本类型和引用类型

基本数据类型

1. 整数类型： byte(1字节) short(2字节) int(4字节) long(8字节)
   -- 整数类型默认是int类型，声明 long 类型需要在后面加 L 或 l, 比如 50L 70l
2. 浮点类型： float(4字节) double(8字节)
   -- 浮点类型默认是 double类型，申明 float 型 需要在后面加 f 或者 F
3. 字符类型： char(1字节)
4. 布尔类型： boolean

进制数字表示

1. 二进制表示法 以0b 或者 0B 开头, 比如 0b11100
2. 八进制表示法 以0开头 如 034
3. 十六进制表示法 以0x开头 或者 0X开头, 比如 0X1C

Unicode 和 UTF-8

1. Unicode 是一个标准，定义了一个字符集和一系列的编码规则，即 unicode 字符集 和 UTF-8 UTF-16 UTF-32 等编码...
2. Unicode字符集为每一个字符分配一个码位, 每一个unicode字符对应2个字节，例如'A' 的码位是0041(16进制)， 在java中表示为\u0041

类型转换

1. 类型转换分自动类型转换和强制类型转换
2. 自动类型转换， 原则是 小范围数据类型可以自动转换为大范围数据类型
   ---- 转换顺序： byte -> short -> int -> long -> float -> double
   ---- char -> int -> long -> float -> double
   ---- byte 和short 类型 与 char 类型 之间 不能相互自动转换
   ---- 示例： double result = floatNum * intNum + doubleNum / shortNum;
3. 强制类型转换: 在变量或常量之前加上(目标类型)， 如： int i = 10; byte b = (byte)i;

引用数据类型

1. 类、接口、数组

控制语句

1. 分支语句 if 和 switch
2. 循环语句 while do-while for
3. 跳转语句 break continue return throw
4. break 和 continue 都可以带标签和不带标签两种方式

for-each 遍历语句

int[] numbers = {10, 20, 30, 40, 50, 60};
for( int item: numbers) {
    System.out.println("Count is:" + item);
}

数组

1. 初始化方式：静态初始化和动态初始化
2. 静态初始化： int[] arr = {1, 2, 3, 4, 5};
3. 动态初始化： int[] arr = new int[5];
4. new分配数组内存空间后, 数组的元素内容是数组类型的默认值，如果是引用类型，则默认值为null

字符串

1. 由双引号括起来
2. "" 空字符串不是null，空字符串会分配内容空间，null不会
3. 三个字符串类：String、StringBuffer和StringBuilder。String是不可变字符串，StringBuffer和StringBuilder是可变字符串
4. java api文档 https://docs.oracle.com/en/java/javase/index.html
5. String类属于 java.lang包，java.lang包提供了很多Java基础类，包括 Object, Class, String, Math等基本类，使用java.lang包中的类时不需要引入（import）该包

创建字符串对象

1. new String() 使用空字符串创建并初始化一个新的String对象
2. new String(String original)：使用另外一个字符串创建并初始化一个新的 String 对象。
3. new String(StringBuffer buffer)：使用可变字符串对象（StringBuffer）创建并初始化一个新的 String 对象。
4. new String(StringBuilder builder)：使用可变字符串对象（StringBuilder）创建并初始化一个新的 String 对象。
5. new String(byte[] bytes)：使用平台的默认字符集解码指定的byte数组，通过byte数组创建并初始化一个新的 String 对象。
6. new String(char[] value)：通过字符数组创建并初始化一个新的 String 对象。
7. new String(char[] value, int offset, int count)：通过字符数组的子数组创建并初始化一个新的 String对象；offset参数是子数组第一个字符的索引，count参数指定子数组的长度。
8. String s9 = "Hello"; 和 String s = new String("Hello"); 是有区别的，Java中的不可变字符串String常量，采用字符串池（String Pool）管理技术

字符串拼接

1. 字符串拼接可以使用+运算符或String的concat(String str)方法。
2. +运算符优势是可以连接任何类型数据拼接成为字符串，而concat方法只能拼接String类型字符串。

String s1 = "Hello";
// 使用+运算符连接，支持+=赋值运算符
s1 += 123;                                   
s1 += "World";    


String s2 = "Hello";
// 使用concat方法连接
s2 = s2.concat(" ").concat("World");
System.out.println(s2);                          

字符串查找

1. indexOf 从前往后 -1表示没找到
2. lastIndexOf 从后往前 -1 表示没找到

String a = new String("hello world!!!");
System.out.println(a.indexOf('a')); // -1
System.out.println(a.indexOf('l')); // 2
System.out.println(a.indexOf('l', 4)); // 9
System.out.println(a.indexOf("lo")); // 3
System.out.println(a.indexOf("l", 5)); // 9

System.out.println(a.lastIndexOf('a')); // -1
System.out.println(a.lastIndexOf('l')); // 9

字符串比较(比较相等、比较大小、比较前缀和后缀)

1. 比较相等: equals、equalsIgnoreCase(忽略大小写)
2. 比较大小: compareTo、compareToIgnoreCase(忽略大小写)
3. 比较后缀: endsWith 测试此字符串是否以指定的后缀结束
4. 比较前缀: startsWith 测试此字符串是否以指定的前缀开始

字符串截取

1. substring(int beginIndex); // 从指定索引beginIndex开始截取一直到字符串结束的子字符串
2. substring(int beginIndex, int endIndex); // 从指定索引beginIndex开始截取直到索引endIndex - 1处的字符

其他字符串方法

1. trim
2. toLowerCase
3. split

可变字符串

1. 可变字符串在追加、删除、修改、插入和拼接等操作不会产生新的对象
2. 两个可变字符串类StringBuffer和StringBuilder，中文翻译为“字符串缓冲区”
3. StringBuffer是线程安全的，它的方法是支持线程同步,线程同步会操作串行顺序执行，在单线程环境下会影响效率。
4. StringBuilder是StringBuffer单线程版本,它不是线程安全的，但它的执行效率很高
5. StringBuffer和StringBuilder具有完全相同的API，即构造方法和普通方法等内容一样
6. StringBuilder的4种构造方法：
   6-1. new StringBuilder() 创建空的StringBuilder对象，初始容量默认为16个字符
   6-2. StringBuilder(CharSequence seq) 指定CharSequence字符串创建StringBuilder对象。CharSequence接口类型，它的实现类有：String、StringBuffer和StringBuilder等，所以参数seq可以是String、StringBuffer和StringBuilder等类型
   6-3. StringBuilder(int capacity) 创建字符串内容是空的StringBuilder对象，初始容量由参数capacity指定的
   6-4. StringBuilder(String str)：指定String字符串创建StringBuilder对象。

字符串长度与容量的区别

字符串长度和字符串缓冲区容量区别。字符串长度是指在字符串缓冲区中目前所包含字符串长度，通过length()获得；字符串缓冲区容量是缓冲区中所能容纳的最大字符数，通过capacity()获得。当所容纳的字符超过这个长度时，字符串缓冲区自动扩充容量，但这是以牺牲性能为代价的扩容

可变字符串的操作方法(追加、插入、删除和替换)

1. 追加： append
2. 插入： insert
3. 删除： delete
4. 替换： replace

面向对象基本特性

1. 封装： 隐藏了对象的内部细节，只保留有限的对外接口
2. 继承： Java语言是单继承的，即只能有一个父类，但Java可以实现多个接口
3. 多态： 多态性是指在父类中成员变量和成员方法被子类继承之后，可以具有不同的状态或表现行为

类

1. 类的语法 [public][abstract|final] class className [extends superclassName] [implements interfaceNameList] {}
2. class 声明类的关键字
3. 成员变量： [public | protected | private ] [static] [final] type variableName; //成员变量
4. 成员方法： [public | protected | private ] [static] [final | abstract] [native] [synchronized] type methodName([paramList]) [throws exceptionList] {
5. static修饰符用于声明静态方法，所以静态方法也称为 类方法
6. final | abstract不能同时修饰方法，final修饰的方法不能在子类中被覆盖；abstract用来修饰抽象方法，抽象方法必须在子类中被实现。
7. native修饰的方法，称为“本地方法”，本地方法调用平台本地代码（如：C或C++编写的代码），不能实现跨平台。
8. synchronized修饰的方法是同步的，当多线程方式同步方法时，只能串行地执行，保证是线程安全的。

方法重载

1. 一个类中可以有多个同名方法，但参数的个数不同或者是参数类型不同，调用时根据参数列表调用相应重载方法。

class MethodOverloading {
    void receive(int i) {                            
        System.out.println("接收一个int参数");
        System.out.println("i = " + i);
    }
    void receive(int x, int y) {                     
        System.out.println("接收两个int参数");
        System.out.printf("x = %d, y = %d \r", x, y);
    }
    int receive(double x, double y) {                
        System.out.println("接收两个double参数");
        System.out.printf("x = %f, y = %f \r", x, y);
        return 0;
    }

2. private

访问控制

1. 访问控制分为4个等级：私有、默认、保护和公有
2. private 私有级别的成员变量和方法只能在其所在类的内部自由使用
3. 默认级别 默认级别没有关键字，也就是没有访问修饰符，默认级别的成员变量和方法，可以在其所在类内部和同一个包的其他类中被直接访问，但在不同包的类中则不允许直接访问
4. protected 保护级别在同一包中完全与默认访问级别一样，但是不同包中子类能够继承父类中的protected变量和方法，这就是所谓的保护级别
5. public，公有级别的成员变量和方法可以在任何场合被直接访问，是最宽松的一种访问控制等级
6. 访问类成员时，在能满足使用的前提下，应尽量限制类中成员的可见性，访问级别顺序是：私有级别→默认级别→保护级别→公有级别

静态变量和静态方法

1. static修饰的成员变量是静态变量
2. staitc修饰的方法是静态方法
3. 调用静态变量或静态方法时，可以通过类名或实例名调用

静态代码块

1. 如果初始化静态变量不是简单常量，需要进行计算才能初始化，可以使用静态（static）代码块
2. 静态代码块在类第一次加载时执行，并只执行一次
3. 静态代码块中可以初始化静态变量，也可以调用静态方法

public class Account {
    // 静态变量利率
    static double interestRate;
    // 静态方法
    public static double interestBy(double amt) {
        // 静态方法可以访问静态变量和其他静态方法
        return interestRate * amt;
    }
    // 静态代码块
    static {                           
        System.out.println("静态代码块被调用...");
        // 初始化静态变量
        interestRate = 0.0668;          
    }
}

对象

1. 类实例化可生成对象，实例方法就是对象方法，实例变量就是对象属性
2. 一个对象的生命周期包括三个阶段：创建、使用和销毁
3. 创建： 创建对象包括两个步骤：声明和实例化
4. 实例化过程分为两个阶段：为对象分配内存空间和初始化对象,new运算符为对象分配内存空间，然后再调用构造方法初始化对象.一个引用变量没有通过new分配内存空间，这个对象就是空对象，Java使用关键字null表示空对象
5. 引用变量默认值是null。当试图调用一个空对象的实例变量或实例方法时，会抛出空指针异常NullPointerException.应该避免调用空对象的成员变量和方法
6. 对象不再使用时应该销毁。C++语言对象是通过delete语句手动释放，Java语言对象是由垃圾回收器（Garbage Collection）收集然后释放，程序员不用关心释放的细节
7. 垃圾回收器（Garbage Collection）的工作原理是：当一个对象的引用不存在时，认为该对象不再需要，垃圾回收器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。

构造方法

1. 构造方法是类中特殊方法，用来初始化类的实例变量，这个就是构造方法，它在创建对象（new运算符）之后自动调用
2. 构造方法名必须与类名相同。
3. 构造方法没有任何返回值，包括void。
4. 构造方法只能与new运算符结合使用。
5. 类可以没有构造方法，Java虚拟机为没有构造方法的类，提供一个无参数的默认构造方法，默认构造方法其方法体内无任何语句，默认构造方法相当于如下代码
6. 一个类中可以有多个构造方法，它们具体有相同的名字（与类名相同），参数列表不同，所以它们之间一定是重载关系
7. 构造方法也可以进行封装，访问级别与普通方法一样

// 矩形类
public class Rectangle {
    // 矩形宽度
    int width;
    // 矩形高度
    int height;
    // 矩形面积
    int area;
    // 构造方法
    public Rectangle(int w, int h) {    
        width = w;
        height = h;
        area = getArea(w, h);
    }
}

this关键字

1. this指向对象本身，一个类可以通过this来获得一个代表它自身的对象变量
2. 使用场景： 调用实例变量 | 调用实例方法 | 调用其他构造方法

继承和多态

1. 类的继承性是面向对象语言的基本特性，多态性的前提是继承性。Java支持继承性和多态性
2. 继承使用的关键字是extends
3. 如果在类的声明中没有使用extends关键字指明其父类，则默认父类为Object类，java.lang.Object类是Java的根类，所有Java类包括数组都直接或间接继承了Object类，在Object类中定义了一些有关面向对象机制的基本方法，如equals()、toString()和finalize()等方法
4. 在Java中，类的继承只能是单继承，而多重继承可以通过实现多个接口实现。也就是说，在Java中，一个类只能继承一个父类，但是可以实现多个接口
5. 子类使用super关键字调用父类构造方法
6. super语句必须位于子类构造方法的第一行

成员变量隐藏和方法覆盖

1. 子类成员变量与父类一样，会屏蔽父类中的成员变量，称为“成员变量隐藏”
2. 调用父类中的被覆盖的成员变量，则需要super关键字
3. 如果子类方法完全与父类方法相同，即：相同的方法名、相同的参数列表和相同的返回值，只是方法体不同，这称为子类覆盖（Override）父类方法
4. 在声明方法时添加@Override注解，@Override注解不是方法覆盖必须的,添加@Override注解有两个好处：提高程序的可读性。编译器检查@Override注解的方法在父类中是否存在，如果不存在则报错。
5. 覆盖后的方法不能比原方法有更严格的访问控制（可以相同）

多态

1. 多态的前提条件： 继承。多态发生一定要子类和父类之间
2. 覆盖。子类覆盖了父类的方法。