Java个人学习笔记

一、基础语法

1.注释只作用在代码环节，编译后的class文件没有注释，所以注释不会影响程序执行

2.多行注释(/* */)和文档注释(/** */)的区别:文档注释一般用在类方法成员变量上,在上面的注释内容会被提取到程序说明文档中

3.变量是内存中的一块区域,我们会给这块区域取名,既变量名,注意驼峰命名法

4.在Java里,局部 变量必须赋予初值才能被使用

5.常用的ASCII: 'A':65,'a':97,'0':48

6.注意,0.00默认是double,所以float x=0.00会报错,应该在后面加个f

7.在表达式里最终的结果类型由表达式中的最高类型决定，表达式里的小范围变量会自动转化为较大范围的类型再参与运算

8.byte、short、char是直接转换成int类型参与运算的

输出：System.out.println();

输入：Scanner sc= new Scanner(System.in);

int age =sc.nextInt();

String name= sc.next();

sc.close()

9.没有赋值功能的表达式不能作为语句

10.switch分支结构的表达式类型不能是double、float、long，现在已经支持枚举和String了

二、数组

1.声明数组变量：int[] i,x 与int x[],i这两种声明方式有区别，和c/c++中的*不同，同时因为[]中没有长度，所以此时并没有被分配内存空间

2.获取数组长度：数组变量.length

3.申请数组存储空间的时候会有默认初值：x=new int[5]

4.对于多维数组，与c/c++不同，其中的元素是分散存储的，比如对于二维数组，他的第一维是连续的，存放是第二维数组的地址，这些第二维数组是分散不连续的，但这些第二维数组的元素又同样是连续存储的

三、方法

1.方法重载（overload）：方法名相同，参数列表不同。Java的方法声明没有参数默认值，需要通过方法重载来达到带默认初值的效果

2.随机数方法：Math.random()

3.可变形式参数"..."：代表形式参数数目可变，放在参数列表的末尾。对于int... x,可以将x视为int[]类型，因为可以理解int...与int[]不能重载的原因

四、字符串

1.约定字符串首字符序号为0，-1代表某字符不在指定的字符串里

2."+"自动将其他类型转化为字符串连接，只有+=能够用于字符串变量

用"+"的话会重新分配新的存储空间来存储新的拼接字符串，不会改变原来的字符串

复制代码

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
sb.append(123); // 支持拼接其他类型
String result = sb.toString(); // 转换为String："Hello World123"

StringBuilder 是可变字符串类，提供 append() 方法拼接内容，效率高于 + 运算符（尤其在循环或频繁拼接场景），因为它不会产生大量临时对象。

3.String类的成员函数

public int length() //返回字符串长度

public char charAt(int i) //返回第i个字符

public boolean equals(Object obj) //比较字符串是否相等

public String substring(int begin,int end) //返回子串

4.我们在用字符串做形参的时候，要考虑空对象的情况（此时对象不指向任何实例），如果是空对象则传化为空串，避免equals（）抛出空对象异常

五、类

1.Java程序设计的基本单位就是类。类是描述对象的数据类型，是静态概念，对象则是动态概念。

2.使用对象的过程：

声明对象所属的类------>

动态申请创建一个指定类的实例（使用new运算符调用类的构造方法创建类的实例，为实例分配内存空间并初始化）------>

让对象引用该实例

3.构造方法：不需要写返回值类型，因为它返回的是该类的一个实例

析构方法：public void finalize();\

4.Java的每个成员方法都可以使用this引用该方法的调用对象，也就是"this引用"

三种用法：

this指代调用成员方法的当前对象自身

用于访问本类的成员变量或者成员方法（此时出现同名问题）

调用本类重载的构造函数，调用本类已经定义的构造方法，此时this（）要放在第一行

5.==、！=运算符比较两个对象是否引用同一个实例，而equals（obj）判断两个对象引用的实例值是否相等

类的访问权限：

只有两种，public和缺省

对于一个源程序文件可以声明多个类，但是public修饰的类只能有一个

类成员的访问权限：

一共有四种，从低到高分别为，private，缺省，protected，public

public等权限修饰符不能修饰方法体中的局部变量

7.使用static声明的成员称为静态成员，也就是类成员，否则就被称为实例成员。实例成员属于对象， 只有创建了实例，才能通过对象访问实例成员变量和调用实例成员方法。类成员属于类， 没有实例也可以通过类名访问静态成员变量和调用静态成员方法

静态成员方法体里，不能访问实例成员，不能使用this引用。类内部，可以直接访问静态成员，省略类名

8.对于引用数据类型，浅拷贝不能实现对象复制功能。如果硬要执行浅拷贝，不会出现运行错误，但是会出现逻辑错误

深拷贝：比如通过new MyDate（p1.birthday）去创建一个新的实例，不会对原本的对象p1造成影响

9.类的继承：

使用关键字extends，Java只支持单继承，不能继承父类的构造方法

object类的成员方法：

public Object（）；

public String toString（）；

public boolean equals（Object obj）；

protected void finalize（） throws Throwable

子类在声明构造方法的时候，可以使用"super引用"来调用父类构造方法，super（）调用必须是第一条语句

10.类的多态性：一种定义，多种实现

方法 覆盖override：参数列表和返回值都相同，子类的访问权限不能小于父类方法的访问权限

方法重载overload：参数列表不同

super将当前对象作为其父类的一个实例引用，静态方法中不能使用super

子类对象即是父类对象，比如说学生一定是人，因此父类对象可以引用子类实例

多态分为编译时多态和运行时多态：只有当出现方法覆盖并且对象引用子类实例的时候才会出现运行时多态

11.最终类

最终类必须用final关键字声明，最终类不能被继承，最终方法不能被子类覆盖，最终类中包含的都是最终方法

final修饰变量的注意:
final修饰基本类型的变量，变量存储的数据不能被改变。
final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

使用了 static final 修饰的成员变量就被称为常量

12.单例类

设计模式：对于一种问题的最优解

单例类：确保某个类只能创建一个对象

java 复制代码

public class B {
// 2、定义一个类变量量用于存储对象
private static B b ; // null
// 1、单例必须私有构造器
private B(){
}
// 3、提供一个类方法返回类的一个对象
public static B getObject(){
if(b == null){
b = new B();
}
return b;
}
}

13.枚举类

枚举类中的第一行，只能写枚举类的对象名称，且要用逗号隔开。

这些名称，本质是常量，每个常量都记住了枚举类的一个对象。

枚举都是最终类 ，不可以被继承，枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象。

14.类的抽象性：本质就是一个模板

在 Java 中有一个关键字叫： abstract ，它就是抽象的意思，可以用它修饰类、成员方法。

**抽象类中不一定要有抽象方法，有抽象方法的类必须是抽象类。**构造方法和静态成员方法不能被声明为抽象类

**抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。**所以构造方法的权限一般为protected，表示为不能用于创建实例，只能留给子类调用

一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

六、接口、内部类

1.接口interface时一组抽象方法、常量和内嵌类型的集合。**接口不能创建对象。**接口是用来被类实现的

一般情况下：

接口中的成员变量都是常量，默认修饰符为public static final，不能声明实例成员变量

接口中的成员方法都是抽象的实例成员方法，默认修饰符为public abstract，不能声明为static

**接口中不能包含构造方法，**因为构造方法无法抽象

接口的访问权限为public或者缺省

接口不能创建实例

但是在JDK8之后：

java 复制代码

public interface A{
/**
* 1、默认方法（实例方法）：使用用 default修饰，默认会被加上 public修饰。
*注意：只能使用接口的实现类对象调用
*/

default void test1(){
...
}

/**
* 2、私有方法：必须用 private修饰 (JDK 9开始才支持 )
*/

private void test2(){
...
}

/**
* 3、类方法（静态方法）：使用 static修饰，默认会被加上 public修饰。
*注意：只能用接口名来调用。
*/

static void test3(){
...
}
}

关键字implements用于声明一个类实现多个指定接口，非抽象类必须实现所有指定接口的所有抽象方法，方法的参数列表必须相同，否则必须声明为抽象类

2.代码块

代码块是类的 5 大成分之一（成员变量、构造器、方法、代码块、内部类）。、

代码块分为两种：

静态代码块 :

格式： static { }

特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。

作用：完成类的初始化，例如：对静态变量的初始化赋值。

实例代码块 :

格式： { }

特点：每次创建对象时，执行实例代码块，并在构造器前执行。

作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

3.内部类：一个类定义在另一个类的内部

java 复制代码

public class Car{
//成员内部类
public class Engine{
}
}

成员内部类中访问其他成员的特点：

1 、成员内部类种可以直接访问外部类的实例成员、静态成员。

2、成员内部类的实例方法中，可以直接拿到当前外部类对象，格式是外部类名.this

创建对象的格式：

外部类名 . 内部类名对象名 = new 外部类 (...).new 内部类(...);

Outer.Inner in = new Outer().new Inner();

java 复制代码

public class Outer{
//静态内部类
public static class Inner{
}
}

静态内部类中访问外部类成员的特点：

可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员。

外部类名 . 内部类名对象名 = new 外部类 . 内部类 (...);

Outer.Inner in = new Outer.Inner();

java 复制代码

// 父类
class Animal {
    public void cry() {
        System.out.println("动物叫");
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建匿名内部类（继承Animal），同时创建实例
        Animal cat = new Animal() {
            // 重写父类的cry()方法
            @Override
            public void cry() {
                System.out.println("猫喵喵叫");
            }
        };

        cat.cry(); // 调用重写后的方法：输出"猫喵喵叫"
    }
}

匿名内部类本质就是一个子类，并会立即创建出一个子类对象。可以更方便的创建出一个子类对象。

4.lambda函数

使用 Lambda 函数替代某些匿名内部类对象，从而让程序代码更简洁，可读性更好。注意 : Lambda 表达式只能替代函数式接口的匿名内部类 !!!

函数式接口：有且仅有一个抽象方法的接口。

具体规则：

参数类型全部可以省略不写。

如果只有一个参数，参数类型省略的同时" ()" 也可以省略，但多个参数不能省略" ()"

如果 Lambda 表达式中只有一行代码，大括号可以不写，同时要省略分号" ;" 如果这行代码是return 语句，也必须去掉 return 。

七、异常

1、异常的体系结构

Java 的异常体系以 Throwable 为根类，分为两大分支：

Error（错误）：由 JVM 抛出的严重错误（如内存溢出 OutOfMemoryError、栈溢出 StackOverflowError），程序无法处理，通常需要修改代码或调整环境。这个程序员无法解决，不用在意就好了
Exception（异常）：程序运行时的非严重错误，可被捕获并处理。分为两类：编译时异常（提示你，这里的代码很容易出bug，类似于防刁民（？）），运行时异常RuntimeException

2.异常处理------throws：把异常抛给上层调用者

throws 是 Java 中用于声明方法可能抛出的异常的关键字，它的作用是告诉调用者："这个方法内部可能会出现这些异常，你需要处理它们"。

方法体声明时说明：

java 复制代码

修饰符 返回值类型 方法名(参数列表) throws 异常类型1, 异常类型2, ... {
    // 方法体（可能抛出上述异常）
}

方法体内部中说明：

java 复制代码

    public static void checkAge(int age) {
        if (age < 0 || age > 150) {
            // 主动抛出 IllegalArgumentException（非受检异常）
            throw new IllegalArgumentException("年龄不合法：" + age);
        }
        System.out.println("年龄合法：" + age);
    }

3.异常处理------try-catch-final：捕获并处理异常

java 复制代码

try {
    // 可能发生异常的代码
} catch (异常类型1 变量名) {
    // 处理异常类型1的逻辑
} catch (异常类型2 变量名) {
    // 处理异常类型2的逻辑（可多个catch，子类异常放前面）
}



try {
    // 可能异常的代码
} catch (Exception e) {
    // 处理异常
} finally {
    // 必须执行的代码（如关闭资源）
    System.out.println("finally块执行");
}

4.自定义异常

1.定义一个异常类继承Exception/RuntimeException

2..重写构造器.

3.通过throw new异常类(xxx)创建异常对象并抛出。