又忘的差不多了，简单总结一下
最下面附有所有测试代码

类与对象的创建

普通类

类中含有属性（字段）和方法
类实例化之后会返回一个自己的对象
同一个类可以产生不同的对象

1 2	Student student = new Student(); Student student1 = new Student();

抽象类

抽象类不能创建对象，不能被实例化
需要通过继承这个类并实现他的抽象方法，才能实例化一个具体的子类
若有抽象方法，类必须为抽象类
抽象方法只有方法名，没有具体实现
若抽象类中有抽象方法，继承的子类必须声明未抽象或实现抽象方法

构造器（构造方法）

一个类即使什么都不写也会存在一个方法（无参构造器）
必须和类的名字相同
必须没有返回类型，也不可有void
若需要有有参构造器时，无参构造器显示定义才能new
若父类只有带参数的构造器，子类必须显示调用父类的带参构造器或显示定义自己的无参构造器，否则无法实例化

作用：

new时调用
初始化对象的值

封装

get/set

继承

子类继承父类的全部方法
所有类都默认继承Object类
final修饰的不可继承

重写（父类功能子类不一定需要或不满足）

重写都是方法的重写，与属性无关
一个类重写了有参构造，必须重写一个无参构造

A是子类，B是父类 （看最下面的测试代码）
有static时，b调用的是B类的方法，因为b是用B类定义的
没有static时，b调用的是对象的方法，因为b是A类new的
静态方法是类的方法，方法的调用与左边有关，也就是与定义的数据类型有关
非静态方法是对象的方法，与new的有关，即b是A new出来的对象，调用了A的方法

static 如果是静态变量，可直接通过类名使用变量

子类

方法名必须同
参数列表必须同
修饰符：范围可以扩大不可缩小
抛出异常：范围可以缩小不可扩大

多态

多态是方法的多态，与属性无关
前提：继承关系，方法需要重写，父类引用指向子类对象

一个对象的实际类型是确定的，可以指向的引用类型不确定
实际类型：new Man();

父类引用指向子类类型

1	Person person = new Man();

对象能执行哪些方法主要看左边类型，与右边无关

若子类重写了父类的方法，调用子类的方法（无论前面类型是什么）
若父类无子类的方法，则不可调用

以下方法不可重写:

static:方法属于类不属于实例
final:常量
private:方法

instanceof

1	x instanceof y

编译通过 -> 有父子关系,左为右父

类型转换

1.父类的引用指向子类对象
2.子转父向上转换不用强转可能丢失一些自己本来的方法
3.父转子向下转换强转

接口

约束和实现分离
声明类的是Class 声明接口的是Interface

作用：

约束
定义一些方法没有具体实现
方法:public abstract void 方法名(); <-默认
属性:public static final 属性名 = 值;
接口不能被实例化，没有构造方法
通过implements关键字实现接口可多继承
类可以实现接口
实现了接口中的类必须实现接口中的所有方法

内部类

非静态内部类

可以访问外部类的实例和方法
通过外部类的实例来创建内部类实例

1 2	Outer outer = new Outer(); Outer.Inner inner = outer.new Inner();

静态内部类

不可访问外部类非静态实例或方法
直接通过外部类名来创建内部类实例

1	Outer.Inner inner = new Outer.Inner();

局部内部类

只能在方法中定义和使用
利用外部类方法实例内部类

1 2	Outer outer = new Outer(); outer.outerMethod();

匿名内部类

没有名字，用于实现接口和继承通过接口实现
用于事件处理、线程创建

异常

异常处理

关键字:try,catch,finally,throw,throws
异常体系结构

自定义异常

快捷键

new 对象（Alt+Enter）
构造器（Alt+Insert）
封装（Alt+Insert）
类层次结构（Ctrl+H）
异常包围（Ctrl+Alt+T）
查看结构（Alt+7）
查看接口的所有实现方法（Ctrl+Alt+B）

测试代码

public class base {
    public static void main(String[] args) {
        //普通类
        //同一个类可以产生不同的对象
        Student student = new Student();
        Student student1 = new Student();

        //封装
        student.setAge(19);
        System.out.println(student.getAge());
        student1.setName("John");
        System.out.println(student1.getName());

        System.out.println("----------------------");

        //抽象类
        Dog dog = new Dog();
        dog.sound();
        dog.sleep();

        System.out.println("----------------------");

        //构造器
        Bot bot = new Bot();
        bot.func("Jump");
        System.out.println("----------------------");

        Son son = new Son();
        son.act();

        System.out.println("----------------------");

        //重写
        A a = new A();
        a.test();  //A有static

        B b = new A();
        b.test();  //B有static

        a.test1(); // A无static
        b.test1(); // A无static

        System.out.println("----------------------");

        //多态
        Person person = new Man();
        Man man = new Man();
        person.run(); //父自己的方法
        man.run();  //子调用父方法
        person.eat();  //
        man.eat();
        man.play(); //子方法父不可调用
    }
}

// ========================================================
class Student{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

// ========================================================
abstract class Ani{
    abstract void sound();
    void sleep(){
        System.out.println("go to Sleep");
    }
}

class Dog extends Ani{
    @Override
    void sound() {
        System.out.println("bark");
    }
}

// ========================================================
class Bot{
    String func;
    Bot(String func){
        this.func = func;
    }

    Bot() {

    }

    void func(String func){
        System.out.println(func);
    }
}

// ========================================================
class Father{
    String name;
    Father(String name){
        this.name = name;
    }
}

class Son extends Father{
    Son(){
        super("Son"); //显示定义自己的无参构造器并调用父类的带参构造器
    }
    void act(){
        System.out.println(name + " is working");
    }
}

// ========================================================
class A extends B{
    public static void test(){
        System.out.println("A有static");
    }
    public void test1(){
        System.out.println("A无static");
    }
}
class B{
    public static void test(){
        System.out.println("B有static");
    }
    public void test1(){
        System.out.println("B无static");
    }
}

// ========================================================
class Person{
    public void run(){
        System.out.println("Person own run");
    }
    public void eat(){
        System.out.println("Person eat");
    }
}

class Man extends Person{
    @Override
    public void eat() {
        System.out.println("Man eat");
    }
    public void play(){
        System.out.println("Man own play");
    }
}