面向对象三大特性

封装：

高内聚：类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅对外暴露少量的方法用于使用

封装的设计思想：隐藏对象内部复杂性，只对外公开简单的接口。

public class Girl {
    //属性
    int age;
    //给age提供一个赋值方法
    //给age提供读取值方法
    //getter setter方法 快捷键 alt＋insert
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
//        if(age > 30){
//        this.age = 18;
//        }
//        else{
//            this.age = age;
//        }
    }
}

public class Test {
    public static void main(String[] args) {
        //创建对象
        Girl g = new Girl();
        g.setAge(40);
        System.out.println(g.getAge());
    }
}

继承：继承是对类的抽象

子类extends父类

Person.java

public class Person {
    //父类中公共的属性
    private int age;
    private String name;
    private double height;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
    //父类公共的方法

    //吃饭
    public void eat(){
        System.out.println("人类要吃饭");
    }
    public void drink(){
        System.out.println("人类要喝水");
    }
    public void sleep(){
        System.out.println("人类要睡觉");
    }

}

Student.java

public class Student extends Person{ //子类继承父类
    //定义子类额外扩展属性
    private int sno;
    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }
    public void study(){
        System.out.println("学生要学习");
    }

}

Test.java

public class Test {
    public static void main(String[] args) {
        //定义一个子类具体的对象
        Student s = new Student();
        s.setSno(2024);
        s.setAge(18);
        s.setHeight(100);
        s.setName("小帅");

        s.study();
        s.drink();
        s.eat();
        s.sleep();
    }
}

方法的重写：

发生在子类和父类中，子类不满意父类的方法，则对父类进行重写。

子类方法名必须和父类一致，参数列表也要和父类一致。

重载和重写的区别：

重载：同一个类，方法名相同，形参列表不同，多个方法构成重载。

重写：不同类中，子类不满意父类的方法，则对父类进行重写。

Person.java

public class Person {
    public void eat(){
        System.out.println("人类可以吃饭");
    }

tsStudent.java

public class Student extends Person{
    public void eat(){
        System.out.println("人类喜欢吃饭");
    }

test.java

public class test {
    public static void main(String[] args) {
        //创建一个学生对象
        Student s = new Student();
        s.eat();
    }
}

多态:通俗来说，就是多种形态;具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。同一种行为，不同的子类呈现出来的状态是不同的。
而不是属性的多态。
PS:多态跟属性无关，多态指的是方法的多念，而不是属性的多态。

Cat.java

public class Cat extends Animal{
    public void shout(){//子类对父类方法不满意
        System.out.println("喵喵");
    }
    public void eat(){
        System.out.println("猫咪喜欢吃饭");
    }
}

Dog.java

public class Dog extends Animal {
    public void shout(){
        System.out.println("汪汪");
    }
    public void beat(){
        System.out.println("狗狗喜欢咬人");
    }
}

Girl.java

public class Girl {
//    public void play(Cat cat){
//        cat.shout();
//    }
//    public void play(Dog dog){
//        dog.shout();
//    }
    public void play(Animal an){
        an.shout();
    }
}

Animal.java

public class Animal {
    //叫
    public void shout(){
        System.out.println("动物叫");
    }
}

Test.java

public class test {
    public static void main(String[] args) {
        //创建小女孩实例，对象
        Girl g = new Girl();
        //创建猫的实例，对象
//        Cat c = new Cat();
//        Dog d = new Dog();
        //女孩陪小猫玩
//        g.play(c);
        Animal an;//定义一个动物
        Cat c = new Cat();//具体的猫
        //Dog d = new Dog;具体的狗
        an = c;//让动物是具体的猫
        //Dog d = new Dog();
        //合成一句 Animal an = new Cat();
                   // Dog an = new Dog();
        g.play(an);
    }
}