JavaSE学习笔记

面向对象

• 面向对象特点：封装性、继承性、多态性、(抽象性)
• 面向对象：不关心具体的步骤，具体的步骤已经由某一个对象完成，考虑哪一个对象完成了这个事情，找到这个对象来做某一件事情。
• 面向过程：需要考虑具体的过程，要自己考虑每一步的实现过程，考虑怎么去做。
• 类和对象：创建类，设计类的属性；创建类的对象；通过 "对象.属性"，"对象.方法"调用对象的结构，功能。
• 万物皆对象：在 Java 语言范畴中，我们将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。(Scanner，String，File，URL)，涉及到Java语言与前端 HTML、后端数据库交互的时候，前后端的结构在Java层面交互的时候都体现为类和对象。

JVM内存结构

• 编译完源程序以后，生成字节码文件；使用 JVM 中的类加载器和解释器对生成的字节码文件进行解释运行。需要将字节码文件对应的类加载到内存中，涉及到内存解析。内存解析是在运行的时候进行的。

方法的使用

• 方法重载(OverLoad)：对于功能类似的方法来说，参数列表不一样，可以使用相同的方法名，多个方法的名称一样，但是参数列表不同，使用一个方法名称，就可以实现相似的多个功能。
• 可变个数形参的格式：数据类型...变量名，可变参数必须声明在形参的末尾。
• 方法递归：方法自身调用自身，使用递归的时候必须添加结束条件，如果没有结束条件将会反生栈溢出。 StackOverflowError，当没有递归出口的时候，方法就会被一直压栈，直到栈内存被全部占满。

递归调用内存图

方法参数的值传递

• 如果变量是基本数据类型，赋值的时候就是变量保存的数据值。如果变量是引用数据类型，赋值的时候就是变量保存的地址值。
• 如果变量作为参数进行值传递，此时在方法中这个值是形参。如果参数是基本数据类型，此时实参给形参的是实参的真实数据值。如果参数是引用数据类型，此时实现给形参的是实参的存储数据的地址值。

代码块

• 作用：跟普通方法一样，完成某一个功能的
• 写法：可以认为程序块是一个 没有修饰符 没有参数 没有返回值 没有名字的特殊方法
• 用法：块也需要调用才能执行 我们自己调用不到(没有名字) 每一次我们调用构造方法之前 系统会帮我们自动的调用一次程序块 让他执行一遍
• 特点：没有什么重载的概念(名字，参数都没有，但是可以在类中定义 多个程序块)
• 块可以在里面写一些程序，在创建对象之前执行

//在运行的时候自动执行
public class Main {
    public static void main(String[] args) {
        {
            System.out.println(5);
        }
    }
}

this关键字

• 构造方法中，属性与变量名重名的时候，this 表示当前对象，是一个关键字(指代词)代替的是某一个对象(当前调用属性或者方法时的那个对象)
• 调用属性或者方法这一行代码可以放置在类中的任何成员位置 上下顺序随意
• this可以调用构造方法：构造方法，一般方法，有顺序，认为构造方法早于一般方法，一般方法内不能调用构造方法，构造方法可以重载，在有参构造方法中调用无参构造方法 this() 省略了构造方法的名字，必须与类名一致，方法之间来回的调用是不可以的。

public class Person {
    int no;
    String name;
    public Person() {
        System.out.println("无参构造方法执行了...");
    }

    public Person(int no, String name) {
        this();
        this.no = no;
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person(2017, "张三");
        System.out.println(person);
    }
}

static关键字

static在属性上：类属性，静态属性

• 类属性的访问可以通过类名.类属性，还可以通过对象.类属性访问。类属性的当前的字节码文件加载进 JVM 的时候，类属性就会被初始化，JVM 执行完毕字节码文件才销毁。
• 类属性可以被每一个对象共享，类方法初始化很早，JVM 加载这个类的时候这个方法就初始化了，对象方法也是很早就进入 JVM，但是不一定被启用了，只有先创建了对象才能调用方法。
• 静态变量对于所有的对象来说都共享一个静态变量，而非类中静态变量对于每一个对象都有单独的一份。

static在方法上：类方法(作为工具类使用)

• 类方法不能访问对象的属性，类方法加载的比较早，也不能调用对象方法。类方法只能访问类属性和类方法。
• 对象方法内可以访问类方法

静态代码块

• 主要用于初始化资源；静态代码块在 main 之前执行，因为静态代码块在类加载的时候就执行了；不能访问对象属性和对象方法，静态方法和静态代码块没有顺序；一个类中可以写多个静态代码块，这些代码块遵循自上而下的顺序依次执行。(如果想要在类进行加载的时候就执行某些代码，那么可以使用静态代码块。)

单例模式 *

类加载机制、字节码知识、JVM 指令重排、Java 序列化机制
一个类只能创建一个实例，设计一个类只能有一个对象，不能创建第二个对象。(线程池，数据库连接池)
实现步骤

• 私有化构造器
• 定义一个类方法用于获得单例的对象，返回值是这个类的类型
• 在类中提供一个私有的 Singleton 类型的类属性(静态属性)
• 实现 getInstance 这个方法

实现方式

• 懒汉模式：使用的时候再进行初始化，延迟加载。

public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton);//cn.edu.zut.Singleton@1b6d3586
        System.out.println(singleton1);//cn.edu.zut.Singleton@1b6d3586
    }
}

//懒汉模式
class Singleton {
    //只能有一个实例
    private static Singleton singleton;
    //私有化构造方法
    private Singleton() {

    }
    public static Singleton getInstance() {
        if (singleton == null) {
            //收到编译器的影响,可能会先执行3,在执行2,指令集进行重新排序,加上volatile(多线程编程)
            //首先在堆空间分配一个空间,然后在栈空间赋值一个引用,分配空间的时候会返回一个该空间的内存引用
            //初始化空间
            //把内存引用赋值给singleton
            singleton = new Singleton();
        }
        return singleton;
    }
}

• 饿汉模式：在类加载的时候就完成了实例的初始化。类加载：加载对应的二进制文件，在方法区，创建对应的数据结构；连接，1.验证，2.准备(给变量初始值)，3.解析；初始化：给静态属性赋值。(通过类加载机制，来保证线程安全。)

public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton);//cn.edu.zut.Singleton@1b6d3586
        System.out.println(singleton1);//cn.edu.zut.Singleton@1b6d3586
    }
}

//饿汉模式
class Singleton {
    //只能有一个实例
    private static Singleton singleton = new Singleton();
    //私有化构造方法
    private Singleton() {

    }
    public static Singleton getInstance() {
        return singleton;
    }
}

• 静态内部类：延迟加载

public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton);//cn.edu.zut.Singleton@1b6d3586
        System.out.println(singleton1);//cn.edu.zut.Singleton@1b6d3586
    }
}

//静态内部类:延迟加载
class Singleton {

    static class InnerClass {
        private static Singleton singleton = new Singleton();
    }

    private Singleton() {

    }
    public static Singleton getInstance() {
        //在调用这个的时候,InnerClass会进行加载
        return InnerClass.singleton;
    }
}

• 反射攻击:通过反射机制来创建不同的实例

public class Main {
    public static void main(String[] args) throws Exception {
        Constructor<Singleton> constructor
                = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton singleton = constructor.newInstance();

        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton);//cn.edu.zut.Singleton@1b6d3586
        System.out.println(singleton1);//cn.edu.zut.Singleton@4554617c
    }
}

class Singleton {

    static class InnerClass {
        private static Singleton singleton = new Singleton();
    }

    private Singleton() {

    }
    public static Singleton getInstance() {
        //在调用这个的时候,InnerClass会进行加载
        return InnerClass.singleton;
    }
}

• 枚举类型：使用反射机制的时候会直接抛出异常，枚举类型不支持反射创建。

public class Main {
    public static void main(String[] args) throws Exception {
        Enum singleton = Enum.SINGLETON;
        Enum singleton1 = Enum.SINGLETON;
        System.out.println(singleton);//SINGLETON
        System.out.println(singleton1);//SINGLETON
        System.out.println(singleton.hashCode());//460141958
        System.out.println(singleton1.hashCode());//460141958

        Constructor<Enum> constructor = Enum.class.getDeclaredConstructor(String.class, int.class);
        constructor.setAccessible(true);
        Enum singleton2 = constructor.newInstance("SINGLETON", 0);
        //java.lang.IllegalArgumentException: Cannot reflectively create enum objects
        //不能对枚举类型进行实例化
        System.out.println(singleton2);

    }
}


enum Enum {
    SINGLETON;
//     0: new           #4                  // class cn/edu/zut/Enum 分配空间
//     3: dup
//     4: ldc           #7                  // String SINGLETON   加载实例
//     6 : iconst_0
//     7: invokespecial #8                  // Method "<init>":(Ljava/lang/String;I)V 调用构造方法
//     10: putstatic     #9                  // Field SINGLETON:Lcn/edu/zut/Enum;  对静态属性进行赋值
//     13: iconst_1
//     14: anewarray     #4                  // class cn/edu/zut/Enum
//     17: dup
//     18: iconst_0
//     19: getstatic     #9                  // Field SINGLETON:Lcn/edu/zut/Enum;
//     22: aastore
//     23: putstatic     #1                  // Field $VALUES:[Lcn/edu/zut/Enum;
//     26: return

}

• 序列化

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Singleton singleton = Singleton.getInstance();
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton"));
        oos.writeObject(singleton);
        oos.close();
        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton"));
        Object obj = ois.readObject();
        Singleton singleton1 = (Singleton) obj;
//        System.out.println(singleton1);//cn.edu.zut.Singleton@378bf509
//        System.out.println(singleton);//cn.edu.zut.Singleton@7f31245a

        //添加Object readResolve() throws ObjectStreamException,接口中的替代方法,防止反序列化攻击
        //枚举类型也可以防止反序列化攻击
        System.out.println(singleton1);//cn.edu.zut.Singleton@7f31245a
        System.out.println(singleton);//cn.edu.zut.Singleton@7f31245a
    }
}

class Singleton implements Serializable {
    private static final long serialVersionUID = -8122532461435652822L;
    private static Singleton singleton = new Singleton();
    private Singleton() {

    }
    public static Singleton getInstance() {
        return singleton;
    }

    Object readResolve() throws ObjectStreamException {
        return singleton;
    }

}