构造器

有参构造：一旦定义了有参构造，无参构造就必须显示定义

构造器：

1. 和类名相同
2. 没有返回值

作用：

1. new本质在调用构造方法
2. 初始化对象的值

封装（属性私有 get/set）

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增强了

class Student{
    //属性私有private
    private int id;
    private String name;
    private String sex;

    //使用get、set提供给外界使用
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

继承（私有的东西无法继承，java类中只有单继承！没有多继承！！）

1. 子类继承了父类，就会拥有父类的全部方法
2. 在java中，所有的类都默认直接继承Object（老祖宗类）
3. extends是扩展的意思，子类是父类的扩展
4. 隐藏代码，调用了父类的无参构造。super();父类构造器，必须在子构造器第一行
5. super和this不能他同时调用构造方法

this和super注意点：

1. 代表对象不同；this本身调用自己这个对象；super代表父类对象的应用
2. this没有继承也可以使用；super只能在继承条件才可以使用
3. this()本类的构造方法；super()父类的构造方法

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//由于学生继承了Person，所以可以使用Person类的方法！
    }
}

class Student extends Person{
    //学生继承了Person
}

class Person {
    public void say(){
        System.out.println("说了一句话");
    }
}

多态（有继承关系、子类重写父类方法、父类引用指向子类对象）

• 注意：多态是方法的多态，属性没有多态性

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//由于学生继承了Person，所以可以使用Person类的方法！

        //父类的引用指向了子类！
        Person person = new Student();
        person.say();
    }
}

class Student extends Person{
    public void say(){
        System.out.println("子类重写了父类的say()方法！");
    }
}

class Person {
    public void say(){
        System.out.println("说了一句话");
    }
}

抽象类（抽象类不能被new出来，只能靠子类去实现它，单继承！只有接口可以多继承）

1. abstract，抽象方法只有方法名字，没有方法的实现
2. 抽象类中可以写普通方法
3. 抽象方法必须在抽象类中
4. 抽象类的所有方法，子类必须要去实现它的方法，除非这个子类也是抽象的

public class Application {
    public static void main(String[] args) {
        //抽象类不能被new出来！
    }
}

//定义抽象类
abstract class Action {
    //定义抽象方法
    public abstract void doSomething();
}

接口

1. interface定义的关键字
2. 接口需要实现类！！！
3. 接口中的所有定义其实都是抽象的
4. 类可以实现接口 implements 接口
5. 实现了接口的类，就必须重写接口中的方法
6. 接口可以实现多继承，一个类可以继承多个接口
7. 抽象不能被实例化！因为抽象，接口中没有构造方法！！！

public class Application {
    public static void main(String[] args) {
        //
    }
}

//interface定义接口,接口需要实现类！！！
interface UserService {
    //定义接口的方法
    void add(int no,String name,String sex);
    void delete(int no);
}

//第二个接口
interface TimeService{
    void getTime();
}

//实现类；接口实现类可以多继承接口！
class UserServiceImpl implements UserService,TimeService{
    //必须重写接口的方法！
    @Override
    public void add(int no, String name, String sex) {
        //方法体
    }

    @Override
    public void delete(int no) {
        //方法体
    }

    @Override
    public void getTime() {
        //方法体
    }
}

重写

1. 需要有继承关系，子类重写父类的方法
2. 方法名必须相同
3. 参数列表必须相同
4. 修饰符，范围可以扩大但不能缩小：public>protected>default>private
5. 重写，子类的方法和父类要一致；方法体不同
6. 为什么要重写？：父类的功能，子类不一定需要，或者不一定满足

注意：

1. 静态（static）方法不能被重写，只有非静态才可以重写
2. final常量和private方法都不能重写，一旦被final父类就不可能被继承
3. 没有重写就没有多态！

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//由于学生继承了Person，所以可以使用Person类的方法！
    }
}

class Student extends Person{
    public void say(){
        System.out.println("子类重写了父类的say()方法！");
    }
}

class Person {
    public void say(){
        System.out.println("说了一句话");
    }
}