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()+ " 正在摸鱼！" );

             }

         }

     }

}