Java面向对象 - 封装、继承和多态的综合练习（答案+知识点总结）第1关：封装、继承和多态进阶（一）+ 第2关：封装、继承和多态进阶（二）

目录

第1关：封装、继承和多态进阶（一）

报错总结 & 注意事项：

第2关：封装、继承和多态进阶（二） 

 源码：

报错总结 & 注意事项：

思维导图免费制作网站： 功能强大

学习方法：头歌中左侧知识点的解释还有右侧代码的提示模块非常清晰，我们可以：

①观察代码整体模块②尝试写代码③不清楚知识点，再将左侧解析放在实例当中去看 [那些注释都给我们写好了，对应注释去敲代码]

如果我们实在啥也不会，参考他人代码，那么也不要全部照抄

【例如】抄完有参构造实例化对象Dog后，自己去敲Cat

第1关：封装、继承和多态进阶（一）

package case1;

import java.util.Scanner;

public class Task1 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String dogName = sc.next();
		String dogSex = sc.next();
		String dogColor = sc.next();
		String catName = sc.next();
		String catSex = sc.next();
		double catWeight = sc.nextDouble();
		/********* begin *********/
		Dog dog = new Dog(dogName,dogSex,dogColor); // 通过有参构造函数实例化Dog类对象dog
		dog.talk(); // dog调用talk()方法
		dog.eat();  // dog调用eat()方法
		/********* end *********/
        /********* begin *********/
		Cat cat = new Cat(catName,catSex,catWeight);// 通过有参构造函数实例化Cat类对象cat
		cat.talk();// cat调用talk()方法
		cat.eat(); // cat调用eat()方法
		/********* end *********/
	}
}

abstract class Pet {
	/********* begin *********/
    String name;// 构造函数初始化name和sex
    String sex;
    Pet(){}  // 定义抽象类Pet，作为基类
    Pet(String name,String sex){ //类中定义2个
        this.name = name;//封装属性name
        this.sex = sex;//封装属性sex
    }
    public abstract void talk(); // 声明抽象方法talk()
    public abstract void eat();  // 声明抽象方法eat()
	/********* end *********/
}
  
class Dog extends Pet { // Dog类继承自Pet类
	/********* begin *********/
    String color;//封装属性color
    public Dog(String name,String sex,String color){
        this.name = name; // 构造函数初始化name、sex和color
        this.sex = sex;
        this.color = color;
    }

    public void talk(){ // 实现自己的talk()方法和eat()方法
        System.out.println("名称：" +name+ "，性别：" +sex+ "，颜色：" +color+ "，汪汪叫");
    }                  // talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'

    public void eat(){ // eat()输出'name吃骨头'
        System.out.println(name+ "吃骨头！");
    }
	/********* end *********/
}


class Cat extends Pet {  // Cat类继承自Pet类 
	/********* begin *********/
    double weight; 
    Cat(String name,String sex,double weight){
        this.name = name; // 构造函数初始化name、sex和weight
        this.sex = sex;
        this.weight = weight; //封装属性weight
    }
    // 实现自己的talk()方法和eat()方法
    public void talk(){
        System.out.println("名称：" +name+ "，性别：" +sex+ "，体重：" +weight+ "kg，喵喵叫");// talk()输出
    }

    public void eat(){
        System.out.println(name+ "吃鱼！"); // eat()输出
    }
	/********* end *********/
}

报错总结 & 注意事项：

1.  最头疼的一个问题，没有代码，题目本身这里显示有问题。代码部分明明正确啊！ 

2. 此处的new 后面应该是Dog类

Dog dog = new Dog(dogName,dogSex,dogColor);

3.此处后面无标点符号

 Pet(){}  

4. 抽象方法声明：

1.public（公有的）：可以被该类的和非该类的任何成员访问。
2.private（私有的）：仅仅可以被该类的成员访问，任何非该类的成员一概不能访问。（主要是隐藏数据来保证数据的安全性）
3.protected（保护的）：仅仅可以被子类和类本身还有同一个包里的类访问

 public abstract void talk(); 

自动默认public类型，代码中所有的public都可以省去不写

第2关：封装、继承和多态进阶（二） 

 源码：

package case2;

import java.util.Scanner;

public class Task2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String cName = sc.next();
		String cSex = sc.next();
		int cAge = sc.nextInt();

		String eName = sc.next();
		String eSex = sc.next();
		int eAge = sc.nextInt();
        // 创建测试类对象test
		Person test;
        // 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
        Person person1 = new Chinese(cName,cSex, cAge);
        showEat(person1);// 通过showEat()方法调用Chinese的eat()方法
		//showEat(new Chinese(cName,cSex,cAge));
        // 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
        Person person2 = new English(eName,eSex,eAge);
        showEat(person2);// 通过showEat()方法调用English的eat()方法
	
		// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
        /********* begin *********/
        Chinese d = (Chinese)person1;
        d.shadowBoxing();
		/********* end *********/
		// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
		/********* begin *********/
        English e = (English)person2;
        e.horseRiding();
		/********* end *********/
	}

	
	/********* begin *********/
    public static void showEat(Person p){// 定义showEat方法，使用父类作为方法的形参，实现多态
        p.eat();//传入的是哪个具体对象就调用哪个对象的eat()方法
    }
	/********* end *********/
}

abstract class Person {// 抽象类Person 封装属性name、sex和age
	/********* begin *********/
    public String name; // 构造函数初始化name、sex和age
    public String sex;
    public int age;
    abstract void eat();// 声明抽象方法eat()
	/********* end *********/
}

class Chinese extends Person { // Chinese类继承自Person类
	/********* begin *********/
    public String name; // 构造函数初始化name、sex和age
    public String sex;
    public int age;
    Chinese(String name,String sex,int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    void eat(){// 重写父类方法eat()
        System.out.println("姓名：" +name+ "，性别：" +sex+ "，年龄：" +age+ "，我是中国人，我喜欢吃饭！");
    }
    void shadowBoxing(){// 定义子类特有方法,当父类引用指向子类对象时无法调用该方法 输出
        System.out.println(name+"在练习太极拳！");
    }
	/********* end *********/
}


class English extends Person { // English类继承自Person类
	/********* begin *********/
    String name;// 构造函数初始化name、sex和age
    String sex;
    int age;
    English(String name,String sex,int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    void eat(){// 重写父类方法eat() 输出
        System.out.println("姓名：" +name+ "，性别：" +sex+ "，年龄：" +age+ "，我是英国人，我喜欢吃三明治！");
    }
    void horseRiding(){
        System.out.println(name+ "在练习骑马！");// 定义子类特有方法,当父类引用指向子类对象时无法调用该方法 输出
    }
	/********* end *********/
}

报错总结 & 注意事项：

1.看见题目注释位置是单引号，一开始打了单引号

单引号：引的数据 是char类型的 单引号只能引一个字符（表示单个字符）

双引号：双引号引的数据 是String类型的 而双引号可以引0个及其以上（引用字符串）

报错原因：定义的String类型

System.out.println(name+"在练习太极拳！");

 2. 最容易漏掉“   ；  ”

Java当中有分号，Python因为简单没有分号！

思维导图免费制作网站： 功能强大

https://www.processon.com/diagramshttps://www.processon.com/diagrams