目录
lys:
1.构造器前面不能加void!!!
2.注意instance
第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();
// 通过有参构造函数实例化Dog类对象dog
// dog调用talk()方法
// dog调用eat()方法
/********* begin *********/
Dog d = new Dog(dogName,dogSex,dogColor);
d.talk();
d.eat();
/********* end *********/
// 通过有参构造函数实例化Cat类对象cat
// cat调用talk()方法
// cat调用eat()方法
/********* begin *********/
Cat c = new Cat(catName,catSex,catWeight);
c.talk();
c.eat();
/********* end *********/
}
}
// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
/********* begin *********/
private String name;
private String sex;
public Pet(){}
public Pet(String name, String sex) {
this.name = name;
this.sex = sex;
}
public void setName(String name){
this.name = name;
}
public void setSex(String sex){
this.sex = sex;
}
public String getSex(){
return sex;
}
public String getName(){
return name;
}
public abstract void talk();
public abstract void eat();
/********* end *********/
}
// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称:name,性别:sex,颜色:color,汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
/********* begin *********/
private String color;
public Dog(){}
public Dog(String name,String sex,String color){
super(name,sex);
this.color = color;
}
public void setColor(String color){
this.color = color;
}
public String getColor(){
return color;
}
public void talk(){
System.out.println("名称:"+getName()+",性别:"+getSex()+",颜色:"+getColor()+",汪汪叫");
}
public void eat(){
System.out.println(getName()+"吃骨头!");
}
/********* end *********/
}
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称:name,性别:sex,体重:weight kg,喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
/********* begin *********/
private double weight;
public void setWeight(double weight){
this.weight = weight;
}
public double getWeight(){
return weight;
}
public Cat(){}
public Cat(String name,String sex,double weight){
super(name,sex);
this.weight = weight;
}
public void talk(){
System.out.println("名称:"+getName()+",性别:"+getSex()+",体重:"+getWeight()+"kg,喵喵叫");
}
public void eat(){
System.out.println(getName()+"吃鱼!");
}
/********* end *********/
}
第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类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
// 通过showEat()方法调用Chinese的eat()方法
// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
// 通过showEat()方法调用English的eat()方法
/********* begin *********/
Person person1 = new Chinese(cName,cSex,cAge);
showEat((Chinese)person1);
Person person2 = new English(eName,eSex,eAge);
showEat(new English(eName,eSex,eAge));
/********* end *********/
// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
/********* begin *********/
Chinese c = (Chinese) person1;
c.shadowBoxing();
English e = (English) person2;
e.horseRiding();
/********* end *********/
}
// 定义showEat方法,使用父类作为方法的形参,实现多态,传入的是哪个具体对象就调用哪个对象的eat()方法
/********* begin *********/
public static void showEat(Person p){
if(p instanceof Chinese){
Chinese c = (Chinese) p;
c.eat();
}
else if(p instanceof English){
English e = (English) p;
e.eat();
}
}
/********* end *********/
}
// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
/********* begin *********/
private String name;
private String sex;
private int age;
Person(){}
Person(String name, String sex,int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public void setSex(String sex){
this.sex = sex;
}
public String getSex(){
return sex;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public abstract void eat();
/********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是中国人,我喜欢吃饭!'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳!'
class Chinese extends Person {
/********* begin *********/
public Chinese(){}
public Chinese(String name,String sex,int age){
super(name,sex,age);
}
public void eat(){
System.out.println("姓名:"+getName()+",性别:"+getSex()+",年龄:"+getAge()+",我是中国人,我喜欢吃饭!");
}
public void shadowBoxing(){
System.out.println(getName() + "在练习太极拳!" );
}
/********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是英国人,我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马!'
class English extends Person {
/********* begin *********/
public English(){}
public English(String name,String sex,int age){
super(name,sex,age);
}
public void eat(){
System.out.println("姓名:"+getName()+",性别:"+getSex()+",年龄:"+getAge()+",我是英国人,我喜欢吃三明治!");
}
public void horseRiding(){
System.out.println(getName()+"在练习骑马!");
}
/********* end *********/
}
第3关:封装、继承和多态进阶(三)
package case3;
import java.util.Scanner;
public class Task3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String pppName = sc.next();
int pppAge = sc.nextInt();
String bpName = sc.next();
int bpAge = sc.nextInt();
String ppcName = sc.next();
int ppcAge = sc.nextInt();
String bcName = sc.next();
int bcAge = sc.nextInt();
// 测试运动员(乒乓球运动员和篮球运动员)
// 乒乓球运动员
// 通过带参构造函数实例化PingPangPlayer对象ppp
// 输出'name---age'
// 分别调用sleep()、eat()、study()、speak()方法
/********* begin *********/
PingPangPlayer p = new PingPangPlayer(pppName,pppAge);
System.out.println(p.getName()+"---"+p.getAge());
p.sleep();
p.eat();
p.study();
p.speak();
/********* end *********/
System.out.println("----------------");
// 篮球运动员
// 通过带参构造函数实例化BasketballPlayer对象bp
// 输出'name---age'
// 分别调用sleep()、eat()、study()方法
/********* begin *********/
BasketballPlayer b = new BasketballPlayer(bpName,bpAge);
System.out.println(b.getName()+"---"+b.getAge());
b.sleep();
b.eat();
b.study();
/********* end *********/
System.out.println("----------------");
// 测试教练(乒乓球教练和篮球教练)
// 乒乓球教练
// 通过带参构造函数实例化PingPangCoach对象ppc
// 输出'name---age'
// 分别调用sleep()、eat()、teach()、speak()方法
/********* begin *********/
PingPangCoach p1 = new PingPangCoach(ppcName,ppcAge);
System.out.println(p1.getName()+"---"+p1.getAge());
p1.sleep();
p1.eat();
p1.teach();
p1.speak();
/********* end *********/
System.out.println("----------------");
// 篮球教练
// 通过带参构造函数实例化BasketballCoach对象bc
// 输出'name---age'
// 分别调用sleep()、eat()、teach()方法
/********* begin *********/
BasketballCoach b1 = new BasketballCoach(bcName,bcAge);
System.out.println(b1.getName()+"---"+b1.getAge());
b1.sleep();
b1.eat();
b1.teach();
/********* end *********/
System.out.println("----------------");
}
}
// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
/********* begin *********/
/********* end *********/
}
// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()(吃的不一样)
abstract class Person {
/********* begin *********/
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age =age;
}
public int getAge(){
return age;
}
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void sleep(){
System.out.println("人都是要睡觉的");
}
public abstract void eat();
/********* end *********/
}
// 定义运动员Player(抽象类)继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样,抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
/********* begin *********/
public Player(){}
public Player(String name,int age){
super(name,age);
}
public abstract void study();
/********* end *********/
}
// 定义教练Coach(抽象类)继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
/********* begin *********/
public Coach(){}
public Coach(String name,int age){
super(name,age);
}
public abstract void teach();
/********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类(兵乓球运动员需要说英语)
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜,喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
/********* begin *********/
public PingPangPlayer(){}
public PingPangPlayer(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("乒乓球运动员吃大白菜,喝小米粥");
}
public void study(){
System.out.println("乒乓球运动员学习如何发球和接球");
}
public void speak(){
System.out.println("乒乓球运动员说英语");
}
/********* end *********/
}
// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口,因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球运动员吃牛肉,喝牛奶'
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
class BasketballPlayer extends Player {
/********* begin *********/
public BasketballPlayer(){}
public BasketballPlayer(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("篮球运动员吃牛肉,喝牛奶");
}
public void study(){
System.out.println("篮球运动员学习如何运球和投篮");
}
/********* end *********/
}
// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类(兵乓球教练需要说英语)
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜,喝大米粥'
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球教练说英语'
class PingPangCoach extends Coach implements SpeakEnglish {
/********* begin *********/
public PingPangCoach(){}
public PingPangCoach(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("乒乓球教练吃小白菜,喝大米粥");
}
public void teach(){
System.out.println("乒乓球教练教如何发球和接球");
}
public void speak(){
System.out.println("乒乓球教练说英语");
}
/********* end *********/
}
// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口,因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球教练吃羊肉,喝羊奶'
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
class BasketballCoach extends Coach {
/********* begin *********/
public BasketballCoach(){}
public BasketballCoach(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("篮球教练吃羊肉,喝羊奶");
}
public void teach(){
System.out.println("篮球教练教如何运球和投篮");
}
/********* end *********/
}