java之继承_java继承的概念

class Person {
    private int age;

    public void setAge(int age) {
        if (age < 0 || age > 200)
            age = 0;
        else {
            this.age = age;
        }
    }

    public int getAge() {
        return age;
    }    

    public void printInfo() {
        System.out.println("age = "+age);
    }

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

    public Person (int age) {
        System.out.println("Person (int age)");
        this.age = age;
    }
    
}

class Student extends Person{
    private String school;

    public void setSchool(String school) {
        this.school = school;
    }

    public String getSchool() {
        return school;
    }    

    public Student(String school) {
        /* will call the super() */
        //super();//如果子类调用父类中默认的构造方法，super()写不写都行
        super(5); //如果子类调用父类中带参数的构造方法，super就必须写，且还要带参数
        System.out.println("Student(String school)");
        this.school = school;
    }

    /* override */
    public void printInfo() {//方法的重写
        System.out.println("school = "+school+"; age = "+getAge());
    }    
}

public class Ext4 {
    public static void main (String args[]) {
        Student stu = new Student("ustc");

        //stu.setAge(10);

        System.out.println(stu.getAge());
        System.out.println(stu.getSchool());
        stu.printInfo();//子类中有实现printInfo方法，就调用子类中的方法；如果没有实现，将会调用父类中的方法
    }
}

class Father {
    private int money;//父类中的私有属性不能被子类访问 public int getMoney() {return money; }
    public void setMoney(int money) {this.money = money; }

    public void printInfo() {System.out.println("This is Father");}

    private void printInfo2() {System.out.println("This is Father");}//父类中的私有方法不能被子类访问
}

class Son extends Father{
    private void printInfo() {System.out.println("This is son");}//会出错，编译不过，因为3.子类覆写的方法不能缩小父类方法的权限 public void printInfo2() {System.out.println("This is Father");}//printInfo2不是对父类中printInfo2方法的复写，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//因为父类中的方法是私有的，子类都不知道有这个方法，这个是子类自己实现的方法
    
}

public class Ext5 {
    public static void main (String args[]) {
        Son son = new Son();
        son.setMoney(100);//由于money是父类中私有的属性，所以不能用son.money=100,即1.父类中的私有属性不能被子类访问 //son.printInfo();
    }
}

abstract class 类名 {
    属性;
    普通方法 { }
    
    // 抽象方法
    访问权限  abstract 返回值类型 方法名 (参数) ; /* 只需要声明，不需要实现 */
}

abstract class Father {//抽象类
    private int money;    

    public int getMoney() {return money; }
    public void setMoney(int money) {this.money = money; }

    public abstract void study();//抽象方法
}

class Son extends Father{
    public void study() {System.out.println("I am study"); }//2. 子类要实现全部的抽象方法
    
}

public class Ext6 {
    public static void main (String args[]) {
        //Father f = new Father();//1. 抽象类不能被实例化对象，会编译出错
        Son son = new Son();
        son.study();
    }
}

// 接口由全局常量、公共的抽象方法组成
interface 接口名称 {
    //属性;
    //方法(1.抽象方法 2.默认方法[default 修饰] 3.静态方法);默认方法和静态方法是jdk8引入的，可以有方法体({})。抽象方法没有方法体{}.
}

如：interface A {
    public static final int i = 10;
    public abstract int getNumber( );
}

abstract class Father {
    private int money;    

    public int getMoney() {return money; }
    public void setMoney(int money) {this.money = money; }

    public abstract void study();
}

interface A {
    public static final int i = 10;//将public static final删除，其还是等效于有public static final，且i不能被修改(i是全局常量)
    public abstract int getNum();//将public abstract删除，其也等效于有public abstract
}

interface B {
    public static String name = "InterfaceB";
    public abstract String getName();
}

class Son extends Father implements A,B{//子类不仅可以继承父类(只能继承一个父类)，还可以实现多个接口
    public int getNum() {return i;}//子类必须覆写全部抽象方法(子类要实现全部的抽象方法)，在{}中写i++;会编译出错，因为i是全局常量
    public String getName() {return name;}
    public void study() {System.out.println("I am study"); }    
}

public class Ext7 {
    public static void main (String args[]) {
        Son son = new Son();
        System.out.println(son.getName());
        son.study();
    }
}