类和对象基础知识储备！！！

• 方法名和类名一致
• 不需要写返回值类型，内部也不必写return语句
• 不需要显式调用，new的时候自动被调用
• 不支持重载
• IDEA 中使用快捷键(Alit+insert)直接创建构造方法

• this指向当前对象的引用，指向当前的实例
• this的类型就是当前这个类的类型
• this这个引用的指向不能修改
• this也可以调用同类下面的方法
• this不能是null

• static表示的含义与其字面没有任何关系
• 如果类中的某个成员加上了static说明这个成员是一个类属性/类方法（与实例没关系），同一个类的不同实例共用一个静态属性；
• 不加static说明这个成员是一个实例属性/实例方法

Cat类：
public class Cat {
    public String name;
    public String gender;
    public int a = 0;

    //加了static后
    //n与类相关，与实例无关
    public static int n = 0;

}

Main类：
public class Main {
   public static void main(String[] args) {
        Cat cat1 = new Cat("小黑","公猫");
        Cat cat2 = new Cat("咪咪","母猫");

        Cat.n++;
        cat1.a++;
        System.out.println(Cat.n);
        System.out.println(cat1.a);
        System.out.println("===============");
        Cat.n++;
        cat2.a++;
        System.out.println(Cat.n);//静态属性与属性无关
        System.out.println(cat2.a);
}
--------------------------------
运行结果：
1
1
===============
2
1

•  static修饰方法和实例无关，只和类有关
• 可以直接调用静态方法，不用创建类的实例

Cat类：
public class Cat {
    public String name;
    public String gender;

    public static void func(){
        System.out.println("这是一个static方法");
    }
}
Main类：
public class Main {
   public static void main(String[] args) {
       //调用静态方法，不用创建实例
       Cat.func();
  }

---------------------------------
运行结果：
这是一个static方法

• 无法在static方法中访问非static的变量和方法，但可以访问static修饰的变量和方法（非静态数据成员和方法都是和实例有关的）
• this和super两个关键字不能在静态上下文中使用（this是当前实例的引用，super是当前实例父类实例的引用，都是和实例有关的）

public class C {
    int a = 0;
    static int b = 0;
    //静态方法
    public static void funs(){
        System.out.println(a);//标红出错
        System.out.println(b);//可访问
    }
}

• static修饰代码块，代码块只是在类加载的时候执行一次，往往用来初始化静态成员；而其他普通代码块实例化多少个就出现多少个

Cat类：
public class Cat {
    public String name;
    public String gender;

    //静态代码块
    static{
        System.out.println("这是一个静态代码块");
    }
    //普通代码块
    {
        System.out.println("这是一个普通代码块");
    }

    public Cat(String name,String gender){
        this.name = name;
        this.gender = gender;

    }
}
Main类：
public class Main {
   public static void main(String[] args) {
        Cat cat1 = new Cat("小黑","公猫");
        Cat cat2 = new Cat("咪咪","母猫");
        Cat cat3 = new Cat("小黑","公猫");
        Cat cat4 = new Cat("咪咪","母猫");

}

-----------------------------------------
运行结果：
这是一个静态代码块
这是一个普通代码块
这是一个普通代码块
这是一个普通代码块
这是一个普通代码块

前提条件：两个类，一个是当前的类A，另一个是要调用类A的类B

注意：面向对象的特性——类和对象、抽象、封装、组合、继承、多态、反射/自省......

其中“三大特性”：多态、继承、封装（访问限定符）

封装的目的就是为了让使用者少了解一些内部信息，如果一个成员变量被private修饰了，这时使用者就获取不到

public：修饰的成员可以被外部的类随意访问

private：只能在类内部使用

protected：搭配继承

default（不写）：包级权限

public修饰的成员访问权限最大，default其次，private最小

可以将一个类定义在另一个类里面或者一个方法里面，这种类称为内部类。包含：静态内部类、成员内部类、匿名内部类、局部内部类。

静态内部类（内部类前面加static）

public class Test {
    static class B{

    }

    public static void main(String[] args) {
        B b1 = new Test.B();
        //在当前类Test中使用时，和静态变量、静态方法类似，也可以把Test.B()略写成B()
        B b2 = new B();
    }
}

和静态变量、静态方法类似，静态内部类也是和当前类(Test)绑定，使用时通过调用Test类来使用

成员内部类

public class Test {

    //1.
    class C{
        int num = 0;
    }
    //2.
    static class C{
        int num = 0;
    }
    public void func(){
        C c = new C();
        c.num = 10;
    }

    public static void main(String[] args) {
        //成员内部类依赖外部类的this,在外部类的static方法中没有this，此时无法实例化
        //1. 
        C c = new C();//出错
        //在成员内部类之前加上static变成静态内部类
        //静态内部类不依赖于this,可以随意创建
        //2. 
        C c = new C();// 变成静态内部类以后正确
    }
}

匿名内部类

public class Test {
    public static void main(String[] args) {

        //创建了一个匿名内部类，此类没有名字
        //这个类是D类的子类（继承自D类）
        D d = new D(){
            //定义属性和方法
        };
    }
}
class D{

}

匿名内部类是使用的非常多的一种内部类，和D d = new D();这样的实例化操作不同，后面还有一个大括号，表示可以重写方法，其实是定义了另外一个类（没有显式的类名，所以叫匿名）。经常用在需要实例化某个对象，但需要重写方法时。