类和对象

类是客观存在的事物，类是确定对象会拥有的特征（属性）和行为（方法），它不是具体客观存在的东西。
由此我们可以总结一下类的特点：

1、类是对象的类型。

2、类是具有相同属性和方法的一组对象集合（一个类可对应多个对象）。

class Stack {
    private int top;
    private int[] elem;
}
public class TestDemo {
    public static void main(String[] args) {
        Stack stack = new Stack();    
    }
}

如上图，Stack为类，如果想要调用类中的方法，就要实例化一个Stack类的对象出来，上图代码中对象为stack

对象的初始化方式

对象的创建要分为两步
1.为对象分配内存
2.调用合适的构造函数

对象的初始化顺序
静态块初始化 (只初始化一次)
实例代码块初始化
构造函数初始化

1.提供一系列get,set方法

class Stack {
    private int top;
    private int elem;
    public void setTop(int top){
        this.top = top;
    }
    public int getTop() {
        return this.top;
    }
    public void setElem(int elem){
        this.elem = elem;
    }
    public int getElem() {
        return this.elem;
    }
}

2.通过合适的构造函数进行初始化

class Person {
    private int age;
    private String name;
    private String sex;

    public Person() {//方法名相同，参数不同，称为重载函数
        this.name = "Allen";
        this.sex = "man";
        this.age = 20;
    }

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

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

3.静态块初始化，实例块初始化

class Person1 {
    private int age;
    private String name;
    private String sex;
    private  static  int count;
//实例块初始化
    {
        this.name = "Allen";
        this.sex = "man";
        this.age = 20;
    }
//静态块初始化
    static {//static所修饰的方法或者数据成员不依赖于对象
        count = 10;
    }
}

内部类

静态内部类

class OutClass {
    private int data1;   
 
    static class InClass {
        public int data;
        OutClass out;

        public InClass(OutClass out) {
            this.out = out;
        }

        public void test2() {
            System.out.println(data);
            System.out.println(out.data1);
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        OutClass.InClass inClass = new OutClass.InClass(outClass);
        inClass.test2();
    }
}

在上面的代码中，data1为外部类的非静态数据成员，需要通过外部类对象访问外部类的非静态数据成员
在内部类中OutClass out为外部类对象，通过out对象访问data1

静态内部类不拥有外部类对象

静态内部类实例化对象语法：
外部类名.内部类名 内部类对象 = new 外部类名.内部类名(外部类对象)

实例内部类

class OutClass {
    public int data1;
    private int data2;
    private static int data3;

    public OutClass() {
        data1 = 111;
        data2 = 222;
        data3 = 333;
    }
    
    class InClass {
        private int data4 = 666;
        public int data5 = 999;
        private static final int DATA = 1000;

        public void test() {
            System.out.println(data1);///111
            System.out.println(data2);///222
            System.out.println(this.data4);///666
            System.out.println(OutClass.this.data3);//333
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        OutClass.InClass inClass = outClass.new InClass();
        inClass.test();
    }
}

实例内部类是否有额外的开销？（有）
此问题即有外部类对象访问内部类数据成员，所以有额外开销

实例内部类是否拥有外部类对象？ （拥有 ）
可以通过外部类.this访问，即可以通过外部类对象访问内部类数据成员，所以拥有外部类对象

实例内部类当中是否可以有静态数据成员？
可以有，但是只能是在编译期间确定的值，被final所修饰

实例内部类对象语法：
外部类名.内部类名 内部类对象 = 外部类对象.new 内部类();

匿名内部类

第一种方法

class OutClass {
}

public class TestDemo {
    public static void main(String[] args) {
        new OutClass() {
            public void sayHello() {
                System.out.println("hello");
            }
        }.sayHello();
    }
}

第二种方法

class OutClass {
    public void sayHello() {
        System.out.println("hello");
    }
}

public class TestDemo {
    public static void test(OutClass out) {
        out.sayHello();
    }

    public static void main(String[] args) {
        test(new OutClass());
    }
}