Educoder -Java面向對象 - 封裝、繼承和多態各關卡題目總結

第1關：什么是封裝，如何使用封裝

　　1、編程要求：

　　根據提示，在右側編輯器Begin-End處補充代碼：

• 聲明一個Person類，私有化屬性name和age，並將字段封裝起來；

• 在Person類中定義一個talk()方法，打印姓名和年齡信息；

• 在main方法中聲明並實例化一Person對象p，給p中的屬性賦值，調用talk()方法打印 我是：張三，今年：18歲。

　　

　　2、測試效果：

　　　　測試輸入： 無

　　　　預期輸出： 我是：張三，今年：18歲

　　

　　3、編程思路：

　　　　（1）看到私有化屬性的封裝，就要想到private關鍵字。

　　　　（2）按照要求定義talk()方法

　　　　（3）由於要給Person類中的私有變量賦值，則需要在Person類中添加對應的get、set方法，最后創建對象后調用talk方法進行打印

　　

　　4、參考答案：　

package case1;
public class TestPersonDemo {
    public static void main(String[] args) {
        /********* begin *********/
        // 聲明並實例化一Person對象p
        Person p = new Person();
        // 給p中的屬性賦值
        p.setName("張三");
        p.setAge(18);
        // 調用Person類中的talk()方法
        p.talk();
        /********* end *********/
    }
}
// 在這里定義Person類
class Person {
    /********* begin *********/
    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;
    }
    void talk() {
        System.out.println("我是：" + name + "，今年：" + age + "歲");
    }
    /********* end *********/
}

 

 

第2關：什么是繼承，怎樣使用繼承

　　1、編程要求：　　

　　根據提示，在右側編輯器Begin-End處補充代碼：

• 聲明一個Animal類，將屬性name和age封裝起來，提供對外的公共訪問方法；

• 聲明一個Cat類和Dog類，都繼承Animal類，分別定義各自的voice方法和eat方法；

• 在main方法中分別實例化一個Cat對象和Dog對象，設置各自的屬性並調用這兩個方法，再打印出名字和年齡信息；

• 具體具體輸出要求請看測試說明。

　　

　　2、測試效果：

　　　　測試輸入：無

　　　　預期輸出：

　　　　大花貓喵喵叫

　　　　大花貓吃魚

　　　　大花貓6歲

　　　　大黑狗汪汪叫

　　　　大黑狗吃骨頭

　　　　大黑狗8歲

　　

　　3、代碼展示：

package case2;

public class extendsTest {
    public static void main(String args[]) {
        // 實例化一個Cat對象，設置屬性name和age，調用voice()和eat()方法，再打印出名字和年齡信息
        /********* begin *********/
          Cat cat= new Cat();
          cat.name="大花貓";
          cat.age=6;
          cat.voice();
          cat.eat();
          System.out.println(cat.name+cat.age+"歲");
        /********* end *********/

        // 實例化一個Dog對象，設置屬性name和age，調用voice()和eat()方法，再打印出名字和年齡信息
        /********* begin *********/
         Dog dog= new Dog();
          dog.name="大黑狗";
          dog.age=8;
          dog.voice();
          dog.eat();
          System.out.println(dog.name+dog.age+"歲");
        /********* end *********/

    }
}

class Animal {
    /********* begin *********/
     protected String name;
     protected 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 ;
     }
    /********* end *********/

}

class Cat extends Animal {
    // 定義Cat類的voice()和eat()方法
    /********* begin *********/
     public void voice(){
         System.out.println(name+"喵喵叫");
     }
     public void eat(){
         System.out.println(name+"吃魚");
     }
    /********* end *********/
}

class Dog extends Animal {
    // 定義Dog類的voice()和eat()方法
    /********* begin *********/
     public void voice(){
         System.out.println(name+"汪汪叫");
     }
     public void eat(){
         System.out.println(name+"吃骨頭");
     }
    /********* end *********/
}

 

第3關：super關鍵字的使用

　　1、編程要求：

• 聲明一個名為Person的類，里面有name與age兩個屬性，並聲明一個含有兩個參數的構造方法；

• 聲明一個名為Student的類，此類繼承自Person類，添加一個屬性school，在子類的構造方法中調用父類中有兩個參數的構造方法；

• 實例化一個Student類的對象s，為Student對象s中的school賦值，打印輸出姓名：張三，年齡：18，學校：哈佛大學。

 

　　2、測試效果：

　　　　測試輸入：無

　　　　預期輸出：

　　　　姓名：張三，年齡：18，學校：哈佛大學

 

　　3、代碼展示：

package case3;

public class superTest {
    public static void main(String[] args) {
        // 實例化一個Student類的對象s，為Student對象s中的school賦值，打印輸出信息
        /********* begin *********/
       Person p= new Person();
       p.setName("張三");
       p.setAge(18);
       p.talk();
       Student stu= new Student();
      
       stu.school="哈佛大學";
       
       System.out.println("，學校："+stu.school);

        /********* end *********/
    }
}

class Person {
    /********* begin *********/
     
      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;
     }

     public void talk(){
         System.out.print("姓名："+name+"，年齡："+age);
     }
    /********* end *********/
}

class Student extends Person {
    /********* begin *********/
    public String school;
     public String getSchool(){
         return school;
     }

    public void setSchool(String name){
        this.school= school;
    }
    /********* end *********/
}

 

第4關：方法的重寫與重載

　　1、編程要求：

• 聲明一個名為Person的類，里面聲明name與age兩個屬性，定義talk()方法返回姓名和年齡信息；

• 聲明一個名為Student的類，此類繼承自Person類，添加school屬性，聲明帶三個參數的構造方法，復寫talk()方法，在該方法中調用父類的talk()方法，返回姓名、年齡和學校信息；

• 實例化子類對象s，調用talk()方法打印我是：張三，今年：18歲，我在哈佛大學上學。

 

　　2、測試效果：　

　　測試輸入： 無

　　預期輸出：

　　我是：張三，今年：18歲，我在哈佛大學上學

 

　　3、代碼展示：

package case4;

public class overridingTest {
    public static void main(String[] args) {
        // 實例化子類對象s，調用talk()方法打印信息
        /********* begin *********/
        Student stu=new Student();
        stu.talk("張三",18,"哈佛大學");
        /********* end *********/
        
    }
}

class Person {
    /********* begin *********/
      String name;
      int age;
      protected void talk(String name, int age){
          this.name=name;
          this.age=age;
        System.out.print("我是："+this.name+"，今年："+this.age);
      }  
    /********* end *********/
}

class Student extends Person {
    /********* begin *********/

    String school;
    
    public void talk(String name,int age,String school){
        
            super.talk("張三",18);
            
        this.school=school;
        System.out.println("歲，我在"+this.school+"上學");
    }
    /********* end *********/
}

 

 

第5關：抽象類

　　1、編程要求：

• 聲明一個名為Person的抽象類，在Person類中聲明了三個屬性name、age和occupation和一個抽象方法talk()；

• 聲明一個Student類和一個Worker類，都繼承自Person類，添加帶有三個參數的構造方法；

• 分別實例化Student類與Worker類的對象，分別調用各自類中被復寫的talk()方法打印輸出信息；

• 具體輸出要求請看測試說明。

 

　　2、測試效果：

　　測試輸入： 無

　　預期輸出：

　　學生——>姓名：張三，年齡：20，職業：學生！

　　工人——>姓名：李四，年齡：30，職業：工人！

 

　　3、代碼展示：

package case5;

public class abstractTest {
    public static void main(String[] args) {
        /********* begin *********/
        // 分別實例化Student類與Worker類的對象，並調用各自構造方法初始化類屬性。
        Student stu=new Student("張三",20,"學生");
        Worker wor=new Worker("李四",30,"工人");
        // 分別調用各自類中被復寫的talk()方法 打印信息。
        stu.talk();
        wor.talk();
        /********* end *********/
        
    }
}

// 聲明一個名為Person的抽象類，在Person中聲明了三個屬性name age occupation和一個抽象方法——talk()。
abstract class Person {
    /********* begin *********/
     protected String name;
     protected int age;
     protected String occupation;
     Person(String name,int age,String occupation){
         this.name=name;
         this.age=age;
         this.occupation=occupation;
     }
     abstract void talk();
    /********* end *********/
}

// Student類繼承自Person類，添加帶三個參數的構造方法，復寫talk()方法 返回姓名、年齡和職業信息
class Student extends Person {
    /********* begin *********/
       
       Student(String name,int age,String occupation) { 
         super(name,age,occupation);
       }
     void talk(){
         System.out.println("學生——>姓名："+name+"，年齡："+age+"，職業："+ occupation+"！");
     }
    /********* end *********/
}

// Worker類繼承自Person類，添加帶三個參數的構造方法，復寫talk()方法 返回姓名、年齡和職業信息
class Worker extends Person {
    /********* begin *********/
       
        Worker(String name,int age,String occupation) { 
         super(name,age,occupation);
       }
         
     void talk(){
         System.out.println("工人——>姓名："+name+"，年齡："+age+"，職業："+occupation+"！");
     }
    /********* end *********/

}

 

第6關：final關鍵字的理解與使用

　　1、編程要求：

• 仔細閱讀代碼，在右側編輯器中調整代碼使程序能正確編譯運行;

• 具體輸出要求請看測試說明。

 

　　2、測試效果：

　　測試輸入：無

　　預期輸出：

　　speedlimit=120

　　running safely with 100kmph

　　running safely with 100kmph

　　

　　3、代碼展示：

package case6;

public class finalTest {
    public static void main(String args[]) {
        Bike1 obj = new Bike1();
        obj.run();

        Honda honda = new Honda();
        honda.run();

        Yamaha yamaha = new Yamaha();
        yamaha.run();
    }
}
//不可以修改 final 變量的值
// final方法,不可以重寫
//// 不可以擴展 final 類
class Bike1 {
     int speedlimit = 90;

    void run() {
        speedlimit = 120; 
        System.out.println("speedlimit=120");
    }

}

class Bike2 {
     void run() {
        System.out.println("running");
    }
}

class Honda extends Bike2 {
    void run() { 
        System.out.println("running safely with 100kmph");
    }

}

 class Bike3 {
}

class Yamaha extends Bike3 { 
    void run() {
        System.out.println("running safely with 100kmph");
    }

}

 

第7關：接口

　　1、編程要求：

• 聲明一Person接口，並在里面聲明三個常量：name、age、occupation，並分別賦值；

• 聲明一Student類，此類實現Person接口，並復寫Person中的talk()方法；

• 實例化一Student的對象s，並調用talk()方法，打印信息；

• 具體輸出要求請看測試說明。

 

　　2、測試效果：

　　測試輸入：無

　　預期輸出：

　　學生——>姓名：張三，年齡：18，職業：學生！

 

　　3、代碼展示：

package case7;

public class interfaceTest {
    public static void main(String[] args) {
        // 實例化一Student的對象s，並調用talk()方法，打印信息
        /********* begin *********/
         Student s =new Student();
         s.talk();
        /********* end *********/

    }
}

// 聲明一個Person接口，並在里面聲明三個常量：name、age和occupation，並分別賦值，聲明一抽象方法talk()
interface Person {
    /********* begin *********/
    String name="張三";
    int age=18;
    String occupation="學生";
    abstract void talk();
    /********* end *********/
}

// Student類繼承自Person類 復寫talk()方法返回姓名、年齡和職業信息
class Student implements Person {
    /********* begin *********/
    public void talk(){
        System.out.println("學生——>姓名："+name+"，年齡："+age+"，職業："+occupation+"！");
    }
    /********* end *********/
}

 

第8關：什么是多態，怎么使用多態

　　1、編程要求：

• 聲明一個Animal類，此類中定義eat()方法；

• 聲明Dog類、Cat類、Lion類，均繼承自Animal類，並復寫了eat()方法；

• 運用多態方式實例化子類對象並調用eat()方法打印輸出信息；

• 具體輸出要求請看測試說明。

 

　　2、測試說明

　　測試輸入：無

　　預期輸出：

　　eating bread...

　　eating rat...

　　eating meat...

 

　　3、代碼展示：

package case8;

public class TestPolymorphism {
    public static void main(String[] args) {
        // 以多態方式分別實例化子類對象並調用eat()方法
        /********* begin *********/
        show(new Dog());
        show(new Cat());
        show(new Lion());
        
    }

    public static void show(Animal a){
        a.eat();
        if(a instanceof Dog){
            
        }else if(a instanceof Cat){
            
        }else{
            
        }
    }
        /********* end *********/
}


// Animal類中定義eat()方法
abstract class Animal {
    /********* begin *********/
   abstract void eat();
    /********* end *********/
}

// Dog類繼承Animal類 復寫eat()方法
class Dog extends Animal {
    /********* begin *********/
     public void eat() {
        System.out.println("eating bread...");
    }
    /********* end *********/
}

// Cat類繼承Animal類 復寫eat()方法
class Cat extends Animal {
    /********* begin *********/
      public void eat() {
        System.out.println("eating rat...");
    }
    /********* end *********/
}

// Lion類繼承Animal類 復寫eat()方法
class Lion extends Animal {
    /********* begin *********/
       public void eat() {
        System.out.println("eating meat...");
    }
    /********* end *********/
}