Java学习笔记（八）------Object类、断点调试、类变量和类方法、main方法、代码块、单例设计模式、final关键字、抽象类、接口、内部类

JDK API 18 在线浏览地址

Object类

equals方法

equals和” == “ 方法的对比：

1.” == “：比较运算符，既可以比较基本类型（比较的是值）又可以比较引用类型（比较的是地址）。   

2.equals 是Object类中的方法，只能判断引用类型。

3.equals 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如：Integer，String。

hashCode方法 

返回该对象的哈希码值。支持此方法是为了提高哈希码的性能。 

1.提高具有哈希结构的容器的效率。

2.两个引用，如果指向的是同一对象，则哈希值肯定是一样的。

3.两个引用，如果指向的是不同对象，则哈希值是不一样的。

4.哈希值主要根据地址号来写的，不能完全将哈希值等价于地址。

5.在集合中haseCode如果需要的话，也会重写。

toString方法

 返回该对象的字符串表示。默认返回：包名加类名+@+哈希值的十六进制。

1.重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式。

2.当直接输出一个对象时，toString方法会被默认的调用。

finalize方法 

 1.当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作。

2.什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。

3.垃圾回收机制的调用，是由系统来决定，也可以通过System.gc() 主动触发垃圾回收机制。

断点调试 （debug）

断点调试是一步步看代码运行的过程，从而发现错误所在。在断点调试中，是运行状态，是以对象的运行类型来执行的。 

1.是指在程序的某一行设置一个断点，调试时，程序运行到这一步就会停住，然后程序员可以控制一步一步往下调试，调试过程中可以看到各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。

2.断点调试也能帮助我们查看java底层源代码的执行过程，提高程序员的java水平。

 类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

语法

访问修饰符 static 数据类型 变量名； （推荐定义法）

                或：static 访问修饰符 数据类型 变量名；

类变量的访问

（依然遵守相关访问权限）：类名.类变量名 （推荐使用）  或者：对象名.类变量名

类的注意事项和使用细节

1. 当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）。

2.类变量与实例对象（普通对象）区别：类变量时该类的所有对象共享的，而示例变量时每个对象独享的。         

3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量

4.实例变量不能通过 类名.类变量名 方式访问。

5.类变量是在类加载时就初始化了，也就是说，即使没有创建对象，只要类加载了，就可以使用类变量了。

6.类变量的生命周期是随着类的加载开始而开始，随着类的消亡而销毁。

类方法 

类方法也叫静态方法。

类方法的表达形式

访问修饰符 数据返回类型 方法名(){   } （推荐使用）

static  访问修饰符 数据返回类型 方法名(){   }

类方法的调用

类名.类方法名     或者:对象名.类方法名 

类方法的使用和注意事项

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区，类方法中无this的参数。（普通方法中隐含着this的参数）

2.类方法可以通过类名调用，也可以通过对象名调用。

3.普通方法和对象有关，需要通过对象名调用，比如 对象名.方法名(参数)，不能通过类名调用。

4.类方法（静态方法）中，只能访问静态变量或静态方法。

5.普通成员方法，既可以访问普通变量（方法），也可以访问静态变量（方法）。

6.类方法中不允许使用和对象有关的关键字，比如this和super。普通方法（成员方法）可以。

main方法 

 main方法的形式：public static void main(String[] args){ }

1.main方法是虚拟机调用。

2.java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public。

3.java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static。

4.该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数。

5.java执行的程序 参数1 参数2 参数3。 

也就是可以在这里面输入args数组的参数。

 main方法特别说明

1.在main()方法中，我们可以直接调用main方法所在类的静态方法或者静态属性。

2. 在main()方法中，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

 代码块

代码块又称为初始化块，属于类中的成员（即是类的一部分），类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但是代码块和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或者类显式调用，而是加载类时或创建对象时隐式调用。

基本语法

[修饰符]{

        代码

};  // ;可以不用加。

代码块说明 

1.修饰符可选，要写的话，也只能写static。

2.代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块。

3.逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）

4.；可以写，也可以不用写。

5.代码块的调用优先于构造器。

 代码块使用细节以及注意事项

1.static代码块是类加载时执行，只会执行一次。

2.普通代码块是在创建对象（new）时调用的，创建一次，执行一次。

3.类加载的三种情况：

        （1）创建对象实例时（new)

        （2）创建子类对象实例，父类对象也会被加载。

        （3）使用类的静态成员时发（静态属性、静态方法）。

4.创建一个对象时，在一个类调用顺序是：

        (1）静态代码块和静态属性初始化。其中静态代码块和静态属性初始化优先级相同，如果有多个，按照顺序调用。

        （2）普通代码块和普通属性初始化。顺序优先级相同，如果有多个，顺序调用。

        （3）构造方法（构造器）。

        因为构造器的最前面隐含了super()和调用普通代码块。例如：

class A{

        //这里隐藏了super()

        //这里隐藏了调用普通代码块

        System.out.println("Hello , world!");

}

5.创建一个子类对象时，调用顺序：

        （1)父类的静态代码块和静态属性。

        （2)子类的静态代码块和静态属性。

        （3）父类的普通代码块和普通属性初始化。

        （4）父类的构造方法。

        （3）子类的普通代码块和普通属性初始化。

        （4）子类的构造方法。

6.静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员。

 单例设计模式

单例设计模式，就是采取一定的方法，保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

单例模式有：饿汉式和懒汉式，两种方式。 

单例模式应用实例

1.构造器私有化。

2.类的内部创建对象。

3.向外暴露一个静态的公共方法。getInstance

4.代码实现。

例如：饿汉式单例模式。

class GirlFriend{
    private String name;

    // 为了能够在静态方法中返回gf对象，需要将其修饰为static
    private static GirlFriend gf = new GirlFriend("小菡");
        
    private GirlFriend(String name){
        this.name = name;
    }
    public static GirlFriend getInstance(){
        return gf;
    }

    // toString 重写方法省略
}

main方法中{
    GirlFriend instance = GirlFriend.getInstance();
    System.out.println(instance); // 这里会输出 ”小菡“
}

 懒汉式单例模式：

class GirlFriend{
    private String name;

    // 为了能够在静态方法中返回gf对象，需要将其修饰为static
    private static GirlFriend gf;
        
    private GirlFriend(String name){
        this.name = name;
    }
    public static GirlFriend getInstance(){
        if(gf == null){
            gf = new GrilFriend("小菡");
        }
        return gf;  //区别是在这里，只有调用的时候才创建新对象，避免空间浪费
    }

    // toString 重写方法省略
}

main方法中{
    GirlFriend instance = GirlFriend.getInstance();
    System.out.println(instance); // 这里会输出 ”小菡“
}

 饿汉式和懒汉式区别

1.最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建。

2.饿汉式不存在线程安全问题，懒汉式存在线程安全问题。

3.饿汉式存在资源浪费的可能。因为如果没有使用对象实例，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，不存在资源浪费的问题。

4.javaSE标准类中，java.lang.Runtime就是经典的单例模式。

 final关键字

final可以修饰类，属性，方法，局部变量等。

final关键字使用场景 

1.不希望类被继承时。

2.不希望父类的某个方法被子类覆盖/重写（override）时。

3.不希望类的某个属性的值被修改。

4.不希望某个局部变量被修改。

 final使用细节

1.final修饰的属性又叫常量，一般用XX_XX_XX（大写字母加下划线）来命名。

2.final修饰符的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在：（1）定义时；（2）在构造器中；（3）在代码块中。定义。

3.如果final修饰的属性是静态的，则初始化的位置只能是(1）定义时；（2）在静态代码块。中定义。但是不能在构造器中赋值。

4.final类不能继承，但是可以实例化对象。

5.如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。

6.一般来说，如果一个类已经是final类了，就没必要再将方法修饰成final方法。

7.final不能修饰构造方法（构造器）。

8.final和static往往搭配使用，效率更高，不会导致类加载。

9.包装类（Integer，Double，Float，Boolean等都是final），String也是final类。

抽象类 

当父类的某些方法需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。

抽象类介绍 

1.用abstract关键字来修饰一个类时，这个类就叫抽象类。

访问修饰符 abstract 类名{}

2.用abstract关键字来修饰一个方法时，这个方法就是抽象方法。

访问修饰符 abstract 返回类型 方法名（参数列表）；// 没有方法体

3.抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类（）。

4.抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多。

抽象类细节 

1.抽象类不能被实例化。

2.抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法。

3.一旦类包含了abstract方法，则这个类必须声明为abstract。

4.abstract只能修饰类和方法，不能修饰属性和其他的。

5.抽象类可以有任意成员（抽象类本质还是类）。

6.抽象方法不能有方法体。

7.如果一个类继承了抽象类，则它必须实现（只要有方法体就叫实现）抽象类的所有抽象方法，除非它自己也声明为abstract类。

8.抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背的。

 接口

 给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据情况把这些方法写出来。

语法

interface 接口名{

        属性；

        方法；}

//可以为抽象方法（可以不加abstract关键字）；默认实现方法；静态方法。

class 类名 implements 接口{

        自己属性；

        自己方法；

        必须实现的接口的抽象方法；}

 接口使用细节和注意事项

1.接口不能被实例化。

2.接口中所有方法是public方法。接口中抽象方法，可以不用abstract修饰。

3.一个普通类实现接口，就必须将该接口的所有方法都实现。

4.抽象类实现接口时，可以不用实现接口的方法。

5.一个类可以同时实现多个接口。

6.接口中的属性，只能是final的，并且是public static final修饰符。

7.接口中属性的访问形式：接口名.属性名。

8.接口不能继承其他的类，但是可以继承多个别的接口。

9.接口的修饰符只能是public和默认，这点和类的修饰符是一样的。

接口的多态特性

1. 接口引用可以指向实现了接口的类的对象。

2.多态数组。

3.接口存在多态传递现象。

 接口和继承

 1.接口和继承解决的问题不同

继承的价值在于：解决代码的复用性和可维护性。

接口的价值在于：设计好各种规范（方法），让其他类去实现这些方法。即更加的灵活。

2.接口比继承更加灵活。

3.接口在一定程度上实现代码解耦。

内部类 

一个类额内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。是类的第五大成员。类的五大成员（属性，方法，构造器，代码块，内部类）。

 最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

内部类的分类

定义在外部类的局部位置上：（1）局部内部类。（有类名）（2）匿名内部类。（没有类名）

定义在外部类的成员位置上：（3）成员内部类。（没用static修饰）（4）静态内部类。 （用static修饰）

局部内部类

定义在外部类的局部位置上。

1.可以直接访问外部类的所有成员，包括私有的。

2.不能添加访问修饰符，但是可以用final修饰。

3.作用域：仅在定义他的方法体或代码块中。

4.局部内部类可以直接访问外部内部类的成员。

5.外部类在方法中可以创建内部类对象，然后调用内部类的方法。

6.外部其他类不能访问局部内部类。

7.如果外部类和局部内部类成员重名时，遵循就近原则。如果想访问外部类的成员使用 外部类名.this.成员 访问。

 匿名内部类（重要）

本质还是类，是内部类，匿名内部类没有名字。

基本语法：

new 类或接口(参数列表){

        类体}; 

匿名内部类的使用细节

1. 匿名内部类既是一个类的定义，同时也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征。

2.可以直接访问外部类的所有成员，包括私有的。

3.不能添加访问修饰符，因为他的地位就是局部变量。

4.作用域：仅在定义他的代码块或方法中。

5.外部其他类不能访问匿名内部类。

6.如果外部类和匿名内部类重名时，内部类访问的话遵循就近原则。如果像访问外部类的成员，则可以使用 外部类名.this.成员 访问。

 成员内部类

成员内部类是定义在外部类的成员位置，并且没有static修饰。

说明

1.可以直接访问外部类的所有成员，包含私有的。

2.可以添加任意的访问修饰符，因为本身就是一个成员。

3.作用域：和外部类一样，为整个类体。

4.成员内部类访问外部类直接访问。（包括私有）

5.外部类访问成员内部类。创建成员内部类对象，然后使用相关方法。

6.外部其他类访问成员内部类。（1）外部类.内部类 对象名 = 内部类对象名.new 内部类名();

（2）该类直接 return new 成员内部类名；

7.如果外部类和匿名内部类重名时，内部类访问的话遵循就近原则。如果像访问外部类的成员，则可以使用 外部类名.this.成员 访问。

静态内部类 

定义在外部类的成员位置，使用static修饰。 

使用说明

1.可以直接访问外部类的所有成员，包含私有的。 

2.可以添加任意的访问修饰符，因为本身就是一个成员。

3.作用域：为整个类体。

4.静态内部类访问外部类。直接访问所有静态成员。

5.外部类访问静态内部类。创建对象再访问。

6.外部其他类访问静态内部类。（1）外部类.静态内部类 对象名 = 外部类.静态内部类名();

7.如果外部类和匿名内部类重名时，内部类访问的话遵循就近原则。如果像访问外部类的成员，则可以使用 外部类名.成员 访问。