java第八课（封装 继承 多态 接口）

1.面向对象的三大特征

封装

多态

继承

1.1封装

在java中为了保护对象的属性和方法，通常通过访问控制符private来保护相应的属性和方法。

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

例如这个Person类，通过private来保护name和age，外界只可以通过set和get方法对name和age进行访问。

1.2多态

所谓的多态其实就是方法的重载和方法的重写。

方法的重写就是子类继承父类的方法可以对父类的方法进行重写，当子类对象调用被重写的方法时，会执行子类中的方法实现。通过方法的重写，可以实现运行时多态。

方法的重载在前面的文章里面详细介绍过，简单来说就是可以定义多个同名方法，但参数列表不同。在调用这些方法时，编译器会根据传入的参数类型和数量来确定调用哪个方法。

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

1.3继承

顾名思义，继承就是可以继承父类里面的属性和方法。

public class parent {
    String dad="1";
    int age=50;
    private int heigh=180;

    public int getHeigh() {
        return heigh;
    }

    public void setHeigh(int heigh) {
        this.heigh = heigh;
    }
    public  void go(){
        System.out.println("bb跑了");
    }
}

这个是父类，

public class childer extends parent{
    public void go(){
        System.out.println("孩子跑了");
    }
    public static void main(String[] args) {
        childer c = new childer();
        System.out.println(c.age);
        System.out.println(c.dad);
        c.go();
        c.setHeigh(100);
        System.out.println(c.getHeigh());
    }
}

这个是子类继承了父类，子类继承父类要在子类后面加extends，并且子类一次只可以继承一个父类，但一个父类可以同时被许多子类继承。

这个就是这个代码运行的结果，在子类中重写父类的方法在调用时会优先使用改写后的代码，通过代码可以发现父类中的heigh不可以直接被调用，这是因为访问控制符的影响，但是可以通过get和set方法来进行得到相应属性的值。

2接口

2.1抽象类

在介绍接口前先介绍一下抽象类，抽象类是一种包含抽象方法的类，不能被实例化，只能被继承。抽象方法是一种没有具体实现的方法，需要子类去实现。抽象类可以包含普通的方法和成员变量，也可以包含抽象方法。

public abstract class Parentss {
    String name="1";
    public abstract void go();
    public void walk(){
        System.out.println("走");
    }
}

要定义抽象类，需要在class前面加abstract，抽象类里面可以定义未完成的方法，也可以定义一个方法，可以通过子类直接调用，但是未定义完成的方法子类必须重写。

可以将鼠标移至红线按alt加回车快速生成需要重写的方法。

public class childer extends Parentss{
    @Override
    public void go(){
        System.out.println("孩子跑了");
    }
    public static void main(String[] args) {
        childer c = new childer();
        c.go();
        c.walk();
        
    }
}

2.2接口

接口是一种抽象类型，它定义了一组抽象方法和常量，但没有实现任何方法。接口可以被类实现，一个类可以实现多个接口。通过实现接口，类可以定义自己的行为，实现接口中定义的方法。在Java中，接口使用关键字"interface"来定义。与抽象类相比，一个子类只可以继承一个抽象类，但是一个子类可以继承许多接口。但是接口不能实例化，但可以通过实现接口的类来创建对象。

// 定义一个接口
interface Animal {
    void eat();
    void sleep();
}
interface go{
void walk();
}

// 实现接口
class Dog implements Animal,go {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping");
    }
    @Override
    public void walk(){
  System.out.println("Dog is walk");
}
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();
        dog.sleep();
dog.walk;
    }
}