JavaSE

1.自增变量

        int i=1;
        i=i++;
        int j=i++;
        int k=i+ ++i*i++;
        System.out.println("i="+i);
        System.out.println("j="+j);
        System.out.println("k="+k);

2.什么是Singleton

单例设计模式，即某个类在整个系统中只能有一个实例对象可被获取和使用的代码模式。

1. 某个类只能有一个实例
   1. 构造器私有化
2. 他必须自行创建这个实例
   1. 含有一个该类的静态变量来保存这个唯一的实例
3. 它必须自行向整个系统提供这个实例
   1. 对外提供获取该实例对象的方法
      1. 直接暴露
      2. 用静态变量的get方法获取

两种常见模式

饿汉式:直接创建对象，不存在线程安全问题

• 直接实例化饿汉式(简浩南观)
• 枚举式(最简洁)
• 静态代码块饿汉式(适合复杂实例化)

/**
        * 饿汉式:
        * 直接创建实例对象,不管你是否需要这个对象都会创建*
        * (1）构造器私有化
        * (2）自行创建，并且用静态变量保存
        * (3）向外提供这个实例
        * (4）强调这是一个单例，我们可以用final修改
*/
public class Singleton1 {
    public  static final Singleton1 INSTANCE =new Singleton1();

    private Singleton1(){
    }

懒汉式:延迟创建对象

• 线程不安全(适用于单线程)
• 线程安全（适用于多线程)
• 静态内部类形式(适用于多线程)
   

    private static singleton4 instance;
    private singleton4(){}

    public static singleton4 getInstance(){
        if(instance == null){
            instance = new singleton4();
        }
        return instance;
    }

3.类初始化和实例初始化

1类初始化

1. 一个类要创建实例需要先加载并初始化该类
   1. main方法所在的类需要先加载和初始化
2. 一个子类要初始化需要先初始化父类
3. 一个类初始化就是执行<clinit>()方法
   1. <clinit>()方法由静态类变量显示赋值代码和静态代码块组成
   2. 类变量显示赋值代码和静态代码块代码从上到下顺序执行
   3. <clinit>()方法只执行一次

2实例初始化

1. 实例初始化就是执行<init>()方法
   1. <init>()方法可能重载有多个，有几个构造器就有几个<init>方法
   2. <init>()方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成
   3. 非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行
   4. 每次创建实例对象，调用对应构造器，执行的就是对应的<init>方法
   5. <init>方法的首行是super()或super(实参列表)，即对应父类的<init>方法

3方法的重写Override

①哪些方法不可以被重写

• final方法
• 静态方法
• private等子类中不可见方法

②对象的多态性

• 子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码
• 非静态方法默认的调用对象是this
• this对象在构造器或者说<init>方法中就是正在创建的对家天下法有难学的北
   

public class Father {
    private int i =test();
    private static int j = method();
    static { System.out.println("(1)"); }
    
    Father(){ System.out.println("(2)"); }
    
    { System.out.println("(3)"); }
    
    public int test(){ 
        System.out.println("(4)");return 1; }
    public static int method(){ 
        System.out.println("(5)");return 1; }
}

public class Son extends Father {
    private int i =test();
    private static int j = method();
    static { System.out.println("(6)"); }
    
    Son(){ System.out.println("(7)"); }
    
    { System.out.println("(8)"); }
    
    public int test(){
        System.out.println("(9)");return 1; }
    public static int method(){
        System.out.println("(10)");return 1;
    }
}

public class test {
    public static void main(String[] args) {
        Son s1 = new Son();
        System.out.println();
        Son s2 = new Son();
    }
}

(5) (1) (10) (6)   (9) (3) (2) (9) (8) (7)

(9) (3) (2) (9) (8) (7)

4.初始化顺序

new子类()

子类初始化<clinit>

• 先初始化父类 （静态代码 （顺序执行））
• 初始化子类（静态代码 （顺序执行））

子类实例化方法<init>:

• super()（最前）
• （顺序）（若有重载，则执行重载，父类被重载方法不执行）
• 无参构造（最后）

4.方法的参数传递机制

public class test1 {
    public static void main(String[] args) {
        int a = 1;
        String b = "hello";
        Integer c = 200;
        int[] d = {1, 2, 3, 4, 5};
        MyData e = new MyData();
        change(a,b,c,d,e);

        System.out.println("a = "+a);
        System.out.println("b = "+b);
        System.out.println("c = "+c);
        System.out.println("d = "+Arrays.toString(d));
        System.out.println("e = "+e.a);
    }
    public static void change(int a1, String b1, Integer c1, int[] d1, MyData e1){
        a1 += 1;
        b1 += " world";
        c1 += 1;
        d1[0] += 1;
        e1.a += 1;
    }
}
class MyData{ int a = 10;}