继承，多态

2024-02-14 14:31:04

第一题:
1.定义一个Animal类,包含如下行为:
eat() 打印"要吃饭"
run() 打印"会跑步"
sleep() 打印"要睡觉"
2.定义一个Dog类,继承Animal类,重写eat(),run()方法
定义自己特有的行为 :
cry() 打印"狗会汪汪叫"
3.定义测试类DogTest, 创建Dog的对象,依次调用eat(),run(),sleep(),cry()方法,打印出如下语句
狗要吃那啥
狗跑的如脱缰的野狗
要睡觉
狗会汪汪叫

Animal类：

继承，多态 
public class Animal {
    public void eat(){
        System.out.println("要恰饭");
    }
    public void run(){
        System.out.println("能跑步");
    }
    public void sleep(){
        System.out.println("会睡觉");
    }
}
继承，多态

Dog类：

继承，多态 
public class Dog extends  Animal{

    @Override
    public void eat(){
        System.out.println("要恰饭啦");
    }
    public void run(){
        System.out.println("准备跑步了塞");
    }
    public void cry(){
        System.out.println("狗还会说话呢");
    }
}
继承，多态

主方法：

继承，多态 
public class Demo01 {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.eat();
        d.run();
        d.sleep();
        d.cry();
    }
}
继承，多态

第二题：

1.定义一个Phone抽象类,包含如下方法:
普通方法: call() 输出:"打电话"
普通方法: sendMessage() 输出:"发短信"
抽象方法: playGame();
2.定义一个IPhone类,继承Phone类
重写sendMessage()方法,输出:"发彩信"
实现playGame()方法,输出:"打王者农药"
定义自己特有的行为 :
siri() 打印"人工智障"
3.定义测试类IPhoneTest, 创建IPhone的对象,调用方法,打印出如下语句
打电话
发彩信
打王者农药
人工智障

Phone类：

继承，多态 
public abstract class Phone {
    public void call(){
        System.out.println("可以打电话啊");
    }
    public void sendMessage(){
        System.out.println("可以发短信啊");
    }
    public abstract void playGame();
}
继承，多态

IPhone类：

继承，多态 
public class IPhone extends Phone{

    @Override
    public void playGame() {
        System.out.println("玩Python动画");
    }
    @Override
    public void  sendMessage(){
        System.out.println("还可以发彩信哈");
    }
    public void siri(){
        System.out.println("人工智能机器人为您服务");
    }
}
继承，多态

主方法：

继承，多态 
public class Demo02 {
    public static void main(String[] args) {
        IPhone i=new IPhone();
        i.call();
        i.sendMessage();
        i.playGame();
        i.siri();
    }
}
继承，多态

第三题：

1.定义Person类,包含空参、满参构造和以下成员变量:
姓名name
年龄age
生成所有成员变量set/get方法
定义方法：void printPerson(),打印出"我是山顶洞人"
2.定义Student继承于Person类,新增如下属性
学校 school
生成空参、满参构造和set/get方法
定义方法:void printStudent(),先输出"我叫XXX,我今年YYY岁,我现在的学校是:ZZZ" 再调用printPerson()方法
3.在测试类中,创建并初始化一个Student 对象 s, 调用printStudent()方法,打印出如下语句:
我叫卡特琳娜,我今年19岁,我现在的学校是:战争学院
我是山顶洞人

Person类：

继承，多态 
public class Person {
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person(String name, int age, String school) {

    }
    public Person(){
    }
    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 printPerson() {
        System.out.println("我是中国人");
    }
}
继承，多态

Student类：

继承，多态 
public class Student extends Person{
    String school;

    public Student(String name, int age, String school) {
        super(name, age,school);
    }

    public Student() {

    }
    public Student(String school) {
        this.school = school;
    }

    public void printStudent() {
        System.out.println("我是" + name + "今年" + age + "我现在的学校是" + school);
        Person p=new Person();
        p.printPerson();
    }
}
继承，多态

主方法：

继承，多态 
public class Demo03 {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("卡特琳娜");
        s1.setAge(19);
        s1.school="战争学院";
        s1.printStudent();
    }
}
继承，多态

第四题:
1.定义抽象类Phone，要求如下：
包含空参、满参构造和以下成员变量
品牌 brand（ String 型）
生成所有成员变量set/get方法
定义抽象方法：void playMusic(String s)
2.定义类IPhone，要求如下：
继承抽象类 Phone
构造方法包括：空参构造和满参构造方法
重写抽象方法：
void playMusic(String s)，要求：输出打印"XXX手机正在播放歌曲:s"
PS：XXX是Phone类中的 brand属性值，s是传入的参数
3.定义测试类TestDemo，在main方法实现以下功能：
创建并初始化一个IPhone 对象 phone，调用phone的playMusic(String s)方法,传入参数"菊花台"
打印出如下语句:
华为手机正在播放歌曲:菊花台

Phone类：

继承，多态 
public abstract class Phone {
    String brand;

    public Phone(String brand) {
        this.brand = brand;
    }
    public Phone(){

    }
    abstract void playMusic(String s);
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public void call(){
        System.out.println("可以打电话啊");
    }
    public void sendMessage(){
        System.out.println("可以发短信啊");
    }
    public abstract void playGame();
}
继承，多态

IPhone类：

继承，多态 
public class IPhone extends Phone{
    void IPhone(){

    }
    void IPhone(String brand){

    }
    @Override
    void playMusic(String s) {
        System.out.println(brand+"手机正在播放音乐:"+s);
    }

    @Override
    public void playGame() {

    }
}
继承，多态

主方法：

继承，多态 
public class Demo04 {
    public static void main(String[] args) {
        IPhone phone=new IPhone();
        phone.setBrand("华为");
        phone.playMusic("菊花爆满山");

    }
}
继承，多态

第五题:
1.定义一个Phone类.包含如下属性
品牌brand
价格price
生成所有成员变量set/get方法,空参构造和有参构造
2.定义一个Person类,包含如下属性
姓名name
年龄age
生成所有成员变量set/get方法,空参构造和有参构造
定义一个玩手机行为 palyPhone(Phone p) 要求打印:"YYY岁的XXX正在玩手机,手机品牌是ZZZ,价格为QQQ
PS：YYY是Person类中的 age属性值，XXX是Person 类中的 name属性值，ZZZ是Phone 类中的 brand属性值,QQQ是Phone 类中的 price属性值"
3.在测试类TestDemo中,创建Person对象ren,调用ren的 palyPhone(Phone p) 方法,打印出 
"40岁的罗永浩正在玩手机,手机品牌是小米,价格为2999"
ps:参数p需要自行创建并初始化变量brand与 price

Phone4类：

继承，多态 
public class Phone4 {
    String brand;
    int price;
    public Phone4(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public Phone4() {

    }

    public void Phone4(){

    }
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}
继承，多态

Person4类：

继承，多态 
public class Person4 extends Phone4{
    String name;
    int age;

    public Person4(String brand, int price) {
        super(brand, price);
    }

    public Person4() {
        super();
    }
    //void palyPhone(Phone4 p){

    //}
    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 palyPhone(Object phone4, Object p) {
        System.out.println(age+"岁的"+name+"正在玩手机,手机品牌是"+brand+"价格为"+price);
    }
}
继承，多态

主方法：

继承，多态 
public class Demo05 {
    private static Object Phone4;
    public static void main(String[] args) {
        Person4 ren=new Person4();
        ren.setName("罗永浩");
        ren.setAge(40);
        ren.setBrand("小米");
        ren.setPrice(2999);
        Object p = null;
        ren.palyPhone(Phone4 ,p);
    }
}
继承，多态

第六题:
1.定义抽象类Study，要求如下：
包含空参、满参构造和以下成员方法
定义抽象方法：void stu(Phone p);
定义普通方法: void info1() 打印"好好学习,天天向上"
定义普通方法: void info2() 打印"键盘敲烂,月薪过万"
2.定义类Phone，要求如下：
包含空参、满参构造和以下成员变量
品牌 brand
价格 price
生成所有成员变量set/get方法
定义方法：void printPhone(),打印出Phone的具体信息,如"XXX手机,价格YYY"
ps: XXX为Phone类的brand属性 yyy为Phone类的price属性
3.定义类Student，包含空参、满参构造和以下成员变量
姓名 name（String 型）
年龄 age（int型）
生成所有成员变量set/get方法
定义成员方法：void studying(Learn le)，要求：
1.输出“yyy岁的xxxx学习中”，
2.然后在方法内通过传入的Learnd对象le依次调用info1()，info2(),stu(Phone p)方法
ps: yyy为Student类中的age方法,xxxx为Student类中的name方法,
ps: Learn继承于Study类，需要实现stu(Phone p)抽象方法，实现要求：调用参数p的printPhone()方法;
4.定义测试类中,创建并初始化一个Student 对象 s, 调用studying(Learn le)方法,打印出如下语句:
15岁的关晓彤学习中
好好学习,天天向上
键盘敲烂,月薪过万
华为手机,价格1999

package com.ben.Demo6;

public class Demo {
public static void main(String[] args) {
    Student s =new Student("关晓彤",15);
    Learn le = new Learn();
    s.studying(le);
}
}
继承，多态 继承，多态 
package com.ben.Demo6;

public class Learn extends Study {
    
    @Override
    void stu(Phone p) {
        // TODO Auto-generated method stub
        p.printPhone();
    }

    
}
继承，多态 继承，多态 
package com.ben.Demo6;

public class Phone {
String brand;
int price;
public String getBrand() {
    return brand;
}
public void setBrand(String brand) {
    this.brand = brand;
}
public int getPrice() {
    return price;
}
public void setPrice(int price) {
    this.price = price;
}
public Phone() {
    super();
}
public Phone(String brand, int price) {
    super();
    this.brand = brand;
    this.price = price;
}
void printPhone(){
    System.out.println(brand+"手机,价格"+price);
}
}
继承，多态 继承，多态 
package com.ben.Demo6;

public class Student {
String name;
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 Student() {
    super();
}

public Student(String name, int age) {
    super();
    this.name = name;
    this.age = age;
}

void studying(Learn le){
    Phone p =new Phone("华为", 1999);
    System.out.println(age+"岁的"+name+"学习中");
    le.info1();
    le.info2();
    le.stu(p);
}
}
继承，多态 继承，多态 
package com.ben.Demo6;

public abstract class Study {
Study(){
    super();
}
abstract void stu(Phone p);

void info1(){
    System.out.println("好好学习,天天向上");
}
void info2(){
    System.out.println("键盘敲烂,月薪过万");
}
}
上一篇：引用图片地址的时候要用require( )包裹起来


下一篇：第八次