面向对象（封装、继承、多态）

目录

封装

继承

多态

---

封装

封装就是把类的属性和方法使用private修饰，不允许类的调用者直接访问。

public class Book {
    private String name;//书名
    private String author;//作者
    private String press;//出版社
    private double price;//价格

 这种就是对属性的封装，在main方法中调用是要用到get和set方法对数据拿取和赋值。

不能直接在main方法中，用对象.属性。

正确的使用方法：

在main方法中，给实例化对象赋值

public class BookTest {
    public static void main(String[] args) {
        Book book = new Book();
        book.setName("百年孤独");
    }
}

继承

继承本质就是实现代码的复用，防止重复的代码多次书写，当一个类继承一个类的时候，该类中就会拥有另外一个类中非私有化的属性和方法。

创建了一个动物类，它里面的属性有名字和年龄，还有一个睡觉的方法

public class Animal {
    String name;
    int age;
    public void sleep(){
        System.out.println("动物会睡觉");
    }
}

还有一个猫类继承动物类

public class Cat extends Animal{
}

最后创建一个测试类，对猫类进行测试：

public class AnimalTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "猫";
        cat.age = 2;
        cat.sleep();
        System.out.println();
    }
}

可以看到猫类继承了动物类非私有化的属性和方法。

同样如果父类中的属性用private修饰，则同样要用到set和get。

public class Animal {
    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;
    }

    public void sleep(){
        System.out.println("动物会睡觉");
    }
}

public class AnimalTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("猫");
        cat.setAge(2);
        cat.sleep();
        System.out.println(cat.getName()+cat.getAge());
    }
}

在继承中，如果子类有与父类一样的方法，但是又有点不一样，则需要用到方法的重写。

创建一个狗类继承动物类：

public class Dog extends Animal{
    @Override
    public void sleep() {
        System.out.println("狗会睡觉");
    }
}

多态

多态是一种思想，是同一份代码，不同的传参（子类）调用会产生不同的效果。
方法层面的多态：就是方法重载
面向对象层面的多态：把子类对象赋给父类的类型

多态分为向上转型和向下转型

向上转型：使用父类对象的引用，引用子类对象

先创建了一个people人类，再创建了一个teacher老师类继承人类，并且重写了人类的work和eat方法。

public class People {
    String name;
    public void work(){
        System.out.println("上班");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}

public class Teacher extends People{
    @Override
    public void work() {
        System.out.println("教书");
    }

    @Override
    public void eat() {
        System.out.println("老师吃饭");
    }
}

再创建一个测试类

public class Test {
    public static void main(String[] args) {
        People people = new Teacher();
        people.work();
    }
}

 Teacher是People的一个子类，使用People引用引用一个Teacher对象，向上转型是自动发生的，不需要进行强制类型转换

向下转型：将父类对象赋值给子类引用

public class Test {
    public static void main(String[] args) {
        People people = new Teacher();
        Teacher teacher = (Teacher) people;
        teacher.work();
    }
}