类的接口、继承与多态

类的接口、继承与多态

继承（Inheritance）

一个类从另一个类获取到的属性与方法的操作，所以继承是单继承，但是可以间接继承。被继承的是父类，继承的是子类。（父类与子类是相对而言，它们是一种真包含的关系）
java的继承性是指子类对象拥有与父类的全部属性与方法，继承意味着“自动拥有”,java不支持多重继承，子类只有一个父类。
注意：与父类/子类相似地位的还有:一般类/特殊类，超类/子类，基类/派生类，前辈类/后裔类
所有的类都会默认继承超类Object，（静态属性可以被继承）

/**
 * 只有创建对象才能真正被继承
 * 创建对象，会先创建父类Person，再到子类
 */
public abstract class Person {
    private String name;
    private String sex;
    private int age;
    public static int score=1000;

    public Person(){
        System.out.println("父类");
    }

    public Person(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    //抽象方法，没有方法体，只能在抽象类在创建，在子类重写
    public abstract String getInfo();

    public String getName() {
        System.out.println("我是父类");
        return name;
    }

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

    public String getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

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

/**
 * 学生类
 */

public class Student extends Person{
    private String Num;
    public static int height=172;
//    public static int score=100;

    public Student() {
        System.out.println("子类");
    }

    @Override
    public String getInfo() {
        return "message is--secrecy";
    }


    public Student(String name, String sex, int age, String num) {
        //super创建父类自身，再在子类调用
        super(name, sex, age);
        Num = num;
    }

    public void showInfo(){
        /**
         * this是使用自身类的属性
         * super是使用父类的属性
         */
        System.out.println("学号："+Num+",名字："+getName()
                +"分数："+super.score+"身高："+height);
    }

    //重写父类的方法
    @Override
    public String getName() {
        System.out.println("我是子类");
        return "1245";
    }

    public String getSuperName(){
        return super.getName();
    }
}

不能被继承的：
1）private 修饰的属性与方法
2）构造方法（因为不能重写它的名称，与构造方法的定义冲突）

抽象类（有约束效果）：
没有足够信息描述的那个类，称为抽象类（无法使用构造方法来实例化自身）
是通过子类来进行实例化

多态（polymorphism）

java的多态性指的是子类继承父类的属性与方法，可以具有与父类不同的数据类型或表现出不同的行为。

//测试上面的Person类与Student类

public class Test01 {
    public static void main(String[] args) {
        Student s=new Student();
        System.out.println(s.getSuperName());
        s.showInfo();
        //p为父类的对象,存在多态性，会先创建Person对象,再创建Student对象
        Person p=new Student();

        System.out.println(p.getName());
//        s.setName("1234");
        //System.out.println(s.getName());
        //只创建Person对象
//        Person p1=new Person();
//        System.out.println(p1.getName());
        //是s1为一个新的Student对象，也是有新的Person对象，不会被上面的s覆盖
//        Student s1=new Student();
//        s1.setName("423");
//        System.out.println(s1.getName());
//        System.out.println(Teacher.score+Student.score);
    }
}

运行截图

接口（Interface）

为了使java具有多继承的功能，java使用了接口技术，继承与接口的双重设计既保证了类的数据类型安全也变相实现了多继承。
所有方法都是抽象方法的特殊抽象类的统称
接口与类是多实现（implement）
接口与接口是多继承（extends）
没有属性，只能写常量（final static）和抽象方法

/**
 * 接口
 */
public interface House {
    public final static String NAME="碧桂园";
    void sleep();
}

public interface Car {
    void start();
}

/**
 * 市场
 */
public interface Market {
    public void food();
}

public interface HouseCar extends House,Car{
    void sleep();
    public void safe();
}

public class Biguiyuan implements House,Market,Car{

    @Override
    public void sleep() {

    }

    @Override
    public void food() {

    }

    @Override
    public void start() {

    }
}