Java轻松掌握面向对象的三大特性封装与继承和多态

public class Student {
    private Double score;
    public void setScore(Double score) {
        //还可以在这里进行属性的判断
        this.score = score;
    }
    public Double getScore() {
        return score;
    }

public class Graduate extends Student{
}

package com.wang.extend;
public class Student {//父类
    public int age;
    public String name;
    private Double score;
    String hobby;
    public Double getScore() {
        return score;
    }

package com.wang.extend;
public class Graduate extends Student {//子类
    public void test() {
        //子类不能直接访问private属性，要调用公共方法得到
        System.out.println("大学生" + name + age + hobby + getScore());
    }
}

package com.wang.extend;
public class Student {//父类
    public int age;
    public String name;
    //public Student() {
    //}
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

package com.wang.extend;
public class Graduate extends Student {
    public Graduate() {
        // super();//默认会有一个调用父类无参构造的方法super()
        //若父类没有无参构造器，必须用super()指定使用哪个构造器 
        super(20,"小明");
    }
}

//正确示例
public Object a()  //父类返回类型为Object
public String a()  //子类返回类型为String或者Object
//Object是String的父类

//接下来是错误示例
void display() //这是子类 子类访问权限为 默认的
public void display() //这是父类 父类访问权限为public
//public->默认的 访问权限变小所以报错

//重载
public int sum(int a,int b);
public int sum(int a,int b,int c);
//重写
class A{
    public void say(){ System.out.printf("A是父类~");}
}
class B extends A{
    public void say() { System.out.printf("B是子类~");}
}

Animal animal = new Dog();//Animal是编译类型，Dog是运行类型
animal = new cat();//编译类型不能改变，运行类型可变

public class Tes {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.n);
        //这里输出的是10，因为属性的值要看编译类型，a的编译类型为A，所以输出的是A的属性
    }
}
class A {
    public int n = 10;
}
class B extends A {
    public int n = 20;
}

public class Test {
    public static void main(String[] args) {
        //向上转型
        A a = new B();
        a.say();
       //a.abc(); 方法abc为运行类型B类特有的编译类型A类不能调用
       //调用那些成员看编译类型，具体运行看运行类型
        //向下转型
        B b = (B) a;
        //父类的引用必须指向的是当前目标类型的对象
        b.abc();
    }
}
class A {
    public void say (){
        System.out.println("A类的say()被调用");
    }
}
class B extends A {
    public void abc(){
        System.out.println("B类的abc()被调用");
    }
    public void say (){
        System.out.println("B类的say()被调用");
    }
}

public class Test {
    public static void main(String[] args) {
        A a = new B();//A为编译类型，B为运行类型
        System.out.println(a.sum());
        //B类中sum()没注释前 结果为 40 注释后结果为 30
        //注释后会调用A类的sum方法但因为动态绑定机制sum中的getI方法调用的是B中的
        System.out.println(a.sum1());
        //B类中sum()没注释前 结果为 30 注释后结果为 20
        //调用A类的sum1，i由于是调用对象的属性，不存在动态绑定机制，哪里声明就调用哪的i=10
    }
}
public class A {
    public int i = 10;
    public int sum() {
        return getI() + 10;
    }
    public int sum1() {
        return i + 10;
    }
    public int getI() {
        return i;
    }
}
public class B extends A {
    public int i = 20;
//    public int sum() {
//        return i + 20;
//    }   
//    public int sum1() {
//        return i + 10;
//    }
    public int getI() {
        return i;
    }
}

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        Employee employee = new Employee("Bob",3000);
        Employee[] employee1 = new  Employee[5];//多态数组 父类定义
        Worker worker = new Worker("Tom",5000);
        Worker worker1 = new Worker("Kit",6000);
        Manager manager = new Manager("Smith",12000,100000);
        Manager manager1 = new Manager("Sab",15000,110000);
        employee1[0]=worker;//可放子类
        employee1[1]=worker1;
        employee1[2]=manager;
        employee1[3]=manager1;
        employee1[4]=employee;//也可放本类
        test.showEmpAnnal(worker);//多态参数 实参可为子类
        test.showEmpAnnal(manager);
        test.testwork(employee1);
    }
    public void showEmpAnnal(Employee e){//多态参数 形参为父类
        System.out.println(e.getName()+" 的年薪为："+e.getAnnual());
    }
    public void testwork(Employee e[]){
        for (int i = 0; i <5 ; i++) {
            if(e[i] instanceof Worker){
                ((Worker) e[i]).work();//向下转型
            }else if(e[i] instanceof Manager){
                ((Manager) e[i]).manage();
            }else {
                System.out.println("员工 "+e[i].getName()+" 正在摸鱼！");
            }
        }
    }
}