java封装执行adb 命令 educoder java封装

转载

码海探险家 2023-08-15 20:14:19

文章标签 java封装执行adb 命令 java 开发语言后端 System 文章分类 Java 后端开发

有手就行！

掌握知识点

…第一关

类的继承
抽象类，抽象方法
super关键字

…第二关（迷了）

类的封装（get（），set（）方法）
类的继承
super关键字
抽象类，抽象方法
类的多态

…第三关（感觉比第二关简单啊）

类的封装
接口
类的继承
super关键字

通关源码（第一关，封装、继承和多态进阶（一））

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 dog = new Dog(dogName,dogSex,dogColor);
        dog.talk();
        dog.eat();
        /********* end *********/
        // 通过有参构造函数实例化Cat类对象cat
        // cat调用talk()方法
        // cat调用eat()方法
        /********* begin *********/
        Cat cat = new Cat(catName,catSex,catWeight);
        cat.talk();
        cat.eat();
        /********* end *********/
    }
}

// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
    /********* begin *********/
    String name;
    String sex;

    Pet(String name,String sex){
         = name;
        this.sex = sex;
    }
    abstract void talk();

    abstract void eat();
    /********* end *********/
}

// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
    /********* begin *********/
    String color;
    Dog(String name,String sex,String color){
        super(name,sex);
        this.color = color;
    }

    void talk(){
        System.out.println("名称：" + name + "，性别：" + sex + "，颜色：" + color +"，汪汪叫");
    }

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

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

    }

    void talk(){
        System.out.println("名称：" + name + "，性别：" + sex + "，体重：" + weigth +"kg，喵喵叫");
    }

    void eat(){
        System.out.print(name + "吃鱼！");
    }
    /********* end *********/
}

java封装执行adb 命令 educoder java封装_java

通关源码（第二关，封装、继承和多态进阶（二））

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(person1);
        Person person2 = new English(eName,eSex,eAge);
        showEat(person2);

        /********* end *********/
        // 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
        // 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
        /********* begin *********/
        Chinese chinese = (Chinese) person1;
        chinese.shadowBoxing();
        English english = (English) person2;
        english.horseRiding();
        /********* end *********/
    }

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

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

    public String getName(){
        return name;
    }

    public void setName(String name){
         = name;
    }

    public String getSex(){
        return sex;
    }

    public void setSex(String sex){
        this.sex = sex;
    }

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        this.age = age;
    }

    public Person(String name,String sex,int age){
         = name;
        this.sex = sex;
        this.age = age;
    }

   public abstract void eat();
    /********* end *********/
}

// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
    /********* begin *********/
    public Chinese(String name,String sex,int age){
        super(name,sex,age);
        name = super.getName();
        sex = super.getSex();
        age = super.getAge();

    }

    public void eat(){
        System.out.println("姓名：" + super.getName() + "，性别：" + super.getSex() + "，年龄：" + super.getAge() + "，我是中国人，我喜欢吃饭！");
    }

    public void shadowBoxing(){
        System.out.println(super.getName() + "在练习太极拳！");
    }
    /********* end *********/
}

// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
    /********* begin *********/
    English(String name,String sex,int age){
        super(name,sex,age);
        name = super.getName();
        sex = super.getSex();
        age = super.getAge();
    }

    public void eat(){
        System.out.println("姓名：" + super.getName() + "，性别：" + super.getSex() + "，年龄：" + super.getAge() + "，我是英国人，我喜欢吃三明治！");
    }

    public void horseRiding(){
        System.out.println(super.getName() + "在练习骑马！");
    }

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

java封装执行adb 命令 educoder java封装_java封装执行adb 命令_02

通关源码（封装、继承和多态进阶（三））

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 ppp = new PingPangPlayer(pppName,pppAge);
        System.out.println(pppName + "---" + pppAge);
        ppp.sleep();
        ppp.eat();
        ppp.study();
        ppp.speak();
        /********* end *********/
        System.out.println("----------------");
        // 篮球运动员
        // 通过带参构造函数实例化BasketballPlayer对象bp
        // 输出'name---age'
        // 分别调用sleep()、eat()、study()方法
        /********* begin *********/
        BasketballPlayer bp = new BasketballPlayer(bpName,bpAge);
        System.out.println(bpName + "---" + bpAge);
        bp.sleep();
        bp.eat();
        bp.study();
        /********* end *********/
        System.out.println("----------------");
        // 测试教练(乒乓球教练和篮球教练)
        // 乒乓球教练
        // 通过带参构造函数实例化PingPangCoach对象ppc
        // 输出'name---age'
        // 分别调用sleep()、eat()、teach()、speak()方法
        /********* begin *********/
        PingPangCoach ppc = new PingPangCoach(ppcName,ppcAge);
        System.out.println(ppcName + "---" + ppcAge);
        ppc.sleep();
        ppc.eat();
        ppc.teach();
        ppc.speak();
        /********* end *********/
        System.out.println("----------------");
        // 篮球教练
        // 通过带参构造函数实例化BasketballCoach对象bc
        // 输出'name---age'
        // 分别调用sleep()、eat()、teach()方法
        /********* begin *********/
        BasketballCoach bc = new BasketballCoach(bcName,bcAge);
        System.out.println(bcName + "---" + bcAge);
        bc.sleep();
        bc.eat();
        bc.teach();
        /********* end *********/
        System.out.println("----------------");
    }
}

// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
    /********* begin *********/
    public abstract void speak();
    /********* end *********/
}

// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()（吃的不一样）
abstract class Person {
    /********* begin *********/
    private String name;
    private int age;
    Person(){

    }

    Person(String name,int age){
         = name;
        this.age = age;

    }

    public String getName(){
        return name;
    }

    public void setName(String name){
         = name;
    }

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        this.age = age;
    }

    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);
        name = super.getName();
        age = super.getAge();
    }

    public abstract void study();
    /********* end *********/
}

// 定义教练Coach（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
    /********* begin *********/
    Coach(){

    }
    Coach(String name,int age){
        super(name,age);
        name = super.getName();
        age = super.getAge();
    }

    public abstract void teach();


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

// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
    /********* begin *********/
    void PingPangPlayer(){

    }

    PingPangPlayer(String name,int age){
        super(name,age);
        name = super.getName();
        age = super.getAge();
    }

    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 *********/
    void BasketBallPlayer(){

    }

    public BasketballPlayer(String name,int age){
        super(name,age);
        name = super.getName();
        age = super.getAge();
    }

    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 *********/
    void PingPangCoach(){

    }
    public PingPangCoach(String name,int age){
        super(name,age);
        name = super.getName();
        age = super.getAge();
    }

    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 *********/
    void BasketballCoach(){

    }
    public BasketballCoach(String name,int age){
        super(name,age);
        name = super.getName();
        age = super.getAge();
    }
    public void eat(){
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
    public void teach(){
        System.out.println("篮球教练教如何运球和投篮");
    }
    /********* end *********/
}

java封装执行adb 命令 educoder java封装_开发语言_03