2021-08-24

1.计算器-----------------------------------------------

```
public interface Count {
        int counts(int x,int y);
}
```

```
public class CountImpl implements Count {
    @Override
    public int counts(int x, int y) {
        return x+y;
    }
```

```
public class CountImpl1  implements Count {
    @Override
    public int counts(int x, int y) {
        return y-x;
    }
```

```
public class CountImpl2 implements Count {
    @Override
    public int counts(int x, int y) {
        return x*y;
    }
```

```
public class CountImpl3 implements Count {
    @Override
    public int counts(int x, int y) {
        return y/x;
    }
}
```

```
public class Test {
    public static void main(String[] args) {
        CountImpl count=new CountImpl();
        System.out.println(count.counts(1,8));
        CountImpl1 count1=new CountImpl1();
        System.out.println(count1.counts(1,8));
        CountImpl2 count2=new CountImpl2();
        System.out.println(count2.counts(1,8));
        CountImpl3 count3=new CountImpl3();
        System.out.println(count3.counts(1,8));
    }
}
```

2.定义抽象类A，抽象类B继承A，普通类C继承B------------------------

```
public abstract class A {
    int numa=10;
    public abstract void showA();
}
```

```
public abstract class B extends A {
    int numb=20;
    public abstract void showB();
}
```

```
public class C  extends B {
    int numc=30;
    public void showA(){
        System.out.println(numa);
    }
    public void showB(){
        System.out.println(numb);
    }
    public void showC(){
        System.out.println(numc);
    }
}
```

```
public class Test {
    public static void main(String[] args) {
        C c=new C();
        c.showA();
        c.showB();
        c.showC();
    }
}
```

3.定义抽象家禽类(Poultry)-----------------------------------------

私有成员变量：动物种类(name)，症状(symptom)，年龄(age)， 病因（illness）

提供空参和带参构造方法

成员方法：
抽象方法 : 显示症状(showSymptom)
普通方法 : 显示基本信息(showMsg)
提供setXxx和getXxx方法
 定义普通鸭子类(Duck)继承家禽类

提供空参和带参构造方法

重写showSymptom方法，打印症状信息。

```package homework.day04.extends2;
package homework.day04.extends2;

public abstract class Poultry {
//    1. 私有成员变量：动物种类(name)，症状(symptom)，年龄(age)， 病因（illness）
//    2. 提供空参和带参构造方法
//    3. 成员方法：
//    抽象方法 : 显示症状(showSymptom)
//    普通方法 : 显示基本信息(showMsg)
//    提供setXxx和getXxx方法
//    定义普通鸭子类(Duck)继承家禽类
//   1. 提供空参和带参构造方法
//   2. 重写showSymptom方法，打印症状信息。
    private String name;
    private String symptom;
    private int age;
    private String illness;

    public String getName() {
        return name;
    }

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

    public String getSymptom() {
        return symptom;
    }

    public void setSymptom(String symptom) {
        this.symptom = symptom;
    }

    public int getAge() {
        return age;
    }

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

    public String getIllness() {
        return illness;
    }

    public void setIllness(String illness) {
        this.illness = illness;
    }

    public Poultry() {
    }

    public Poultry(String name, String symptom, int age, String illness) {
        this.name = name;
        this.symptom = symptom;
        this.age = age;
        this.illness = illness;
    }
    //    抽象方法 : 显示症状(showSymptom)
    public abstract void showSymptom();
    //    普通方法 : 显示基本信息(showMsg)
    public void showMsg(){
        System.out.println("Poultry{" +
                "name='" + name + '\'' +
                ", symptom='" + symptom + '\'' +
                ", age=" + age +
                ", illness='" + illness + '\'' +
                '}');
    }
}
```

​       

```
public  class Duck extends Poultry {

    public Duck() {
    }

    public Duck(String name, String symptom, int age, String illness) {
        super(name, symptom, age, illness);
    }

    @Override
    public void showSymptom() {
        System.out.println("我的症状是" + this.getSymptom());
    }
}
```

```
public class Text {
    public static void main(String[] args) {
        Duck duck=new Duck("大黄鸭","高烧不退",25,"蹦迪太猛");
        duck.showSymptom();
        duck.showMsg();
    }
}
```

4.定义Person类。----------------------------------------------------

属性：姓名、年龄

构造方法：无参构造方法，有参构造方法

成员方法：getXxx方法，setXxx方法，显示基本信息showMsg方法
定义Teacher类，继承Person

属性：学科

构造方法：无参构造方法，有参构造方法

成员方法：getXxx方法，setXxx方法，讲课方法
定义Student类，继承Person

属性：分数

构造方法：无参构造方法，有参构造方法

成员方法：getXxx方法，setXxx方法，考试方法

```
public class Person {
    //定义Person类。
    //1. 属性：姓名、年龄
    //2. 构造方法：无参构造方法，有参构造方法
    //3. 成员方法：getXxx方法，setXxx方法，显示基本信息showMsg方法
    String pName;
    String pAge;

    public Person() {
    }

    public Person(String pName, String pAge) {
        this.pName = pName;
        this.pAge = pAge;
    }

    public String getpName() {
        return pName;
    }

    public void setpName(String pName) {
        this.pName = pName;
    }

    public String getpAge() {
        return pAge;
    }

    public void setpAge(String pAge) {
        this.pAge = pAge;
    }
    public void showMsg(){
        System.out.println("Person{" +
                "pName='" + pName + '\'' +
                ", pAge='" + pAge + '\'' +
                '}');
    }
}
```

```
public class Student extends Person{
//    定义Student类，继承Person
//1. 属性：分数
//2. 构造方法：无参构造方法，有参构造方法
//3. 成员方法：getXxx方法，setXxx方法，考试方法
    double grades;

    public double getGrades() {
        return grades;
    }

    public void setGrades(double grades) {
        this.grades = grades;
    }

    public Student(double grades) {
        this.grades = grades;
    }
    public Student(){}
    public Student(String pName, String pAge, double grades) {
        super(pName, pAge);
        this.grades = grades;
    }
    public void test(){
        System.out.println("学生考试");
    }
}
```

```
public class Teacher extends Person {
    //    定义Teacher类，继承Person
//1. 属性：学科
//2. 构造方法：无参构造方法，有参构造方法
//3. 成员方法：getXxx方法，setXxx方法，讲课方法
    String subject;

    public Teacher() {
    }

    public Teacher(String pName, String pAge, String subject) {
        super(pName, pAge);
        this.subject = subject;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }
    public void teacherMethod(){
        System.out.println("网上授课");
    }
}
```

```
public class Test {
    //定义Test4测试类，测试showMsg方法 ，讲课方法 ，考试方法。

    public static void main(String[] args) {
        Student student = new Student("托塔天王", "28", 89);
        Teacher teacher = new Teacher("吴彦祖", "88", "语文");
        student.test();
        student.showMsg();
        teacher.teacherMethod();
        teacher.showMsg();
    }
}
```

5计算面积和周长----------------------------------------------------

```
public abstract class Shape {
//    定义形状抽象类Shape,定义抽象方法计算周长和面积
//    定义子类矩形Rectangle和子类圆形Circle继承Shape类
//    Rectangle编写有参构造方法(长,宽),重写计算周长和面积的方法
//    Circle编写有参构造方法(半径),重写计算周长和面积的方法
public  abstract void perimeter();
public  abstract void area();
}
```

```
public class Rectangle extends Shape {
    double x;
    double y;

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public Rectangle(double x, double y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public void perimeter() {
        System.out.println("长方形周长"+(x+y)*2);
    }

    @Override
    public void area() {
        System.out.println("长方形面积:"+x*y);
    }
}
```

```
public class Circle extends Shape{
    double r;

    public Circle(double r) {
        this.r = r;
    }
    public Circle() {
    }
    public double getR() {
        return r;
    }

    public void setR(double r) {
        this.r = r;
    }

    @Override
    public void perimeter() {
        System.out.println("圆形周长"+3.14*r*2);
    }

    @Override
    public void area() {
        System.out.println("圆形面积:"+3.14*r*r);
    }
}
```

```
public class Test {
    public static void main(String[] args) {
        Rectangle rectangle=new Rectangle(12,54);
        rectangle.perimeter();
        rectangle.area();
        Circle circle=new Circle(23);
        circle.area();
        circle.perimeter();
    }
}
```

6.--------------------------------------------------------------

定义员工Employee类。包含属性：姓名，工号，部门。

定义经理Manager类继承Employee类，包含属性：职员(该经理的职员)。

定义职员Clerk类继承Employee类，包含属性：经理(该职员的经理)。

```
package homework.day04.extend5;

public class Employee {
//    1. 定义员工Employee类。包含属性：姓名，工号，部门。
 String name;
 int no;
 String dept;

    public Employee() {
    }

    public Employee(String name, int no, String dept) {
        this.name = name;
        this.no = no;
        this.dept = dept;
    }

    public String getName() {
        return name;
    }

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

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getDept() {
        return dept;
    }

    public void setDept(String dept) {
        this.dept = dept;
    }
}
```

```
package homework.day04.extend5;

public class Clerk extends Employee {
    //    3. 定义职员Clerk类继承Employee类，包含属性：经理(该职员的经理)。
    String boos;

    public String getBoos() {
        return boos;
    }

    public void setBoos(String boos) {
        this.boos = boos;
    }

    public Clerk(String boos) {
        this.boos = boos;
    }

    public Clerk(String name, int no, String dept, String boos) {
        super(name, no, dept);
        this.boos = boos;
    }
}
```

```
package homework.day04.extend5;

public class Manager extends Employee{
//2. 定义经理Manager类继承Employee类，包含属性：职员(该经理的职员)。
    String people;

    public Manager(String people) {
        this.people = people;
    }

    public Manager(String name, int no, String dept, String people) {
        super(name, no, dept);
        this.people = people;
    }

    public String getPeople() {
        return people;
    }

    public void setPeople(String people) {
        this.people = people;
    }
}
```

```
package homework.day04.extend5;

public class Test {
    public static void main(String[] args) {
        Employee employee=new Employee("张三丰",01,"销售部");
        Manager manager=new Manager("黄大发",02,"销售部","张三丰");
        System.out.println(employee.dept+"的:"+employee.name+"员工编号："+employee.no+"    他的上司是："+manager.name);
        System.out.println(manager.dept+"的:"+manager.name+"员工编号："+employee.no+"    他的职员是："+employee.name);
    }
}
```

继承第一天，看了你就是无敌的