继承多态封装

1.继承用单词extends。一般子类可以继承父类的方法和属性，但是私有的能继承，但子类不能使用，在子类访问父类的构造方法需要用到super关键字，一般super放在mian方法的第一行，并且只要继承，系统会默认调用父类的无参构造方法。并且如果是连续继承，无参构造方法会从最上面层的父类开始调用。如果调用本类的方法，则使用this关键字。

2.多态，指的是多种形式。它使用不同的实例而执行不同的操作。多态包括方法的重写和方法的重载，方法的重写是使用继承时对父类的方法进行重写，比如形状有绘图的方法，在其子类三角形和正方形中。有绘图的方法，所以在其子类中对方法进行重写，使其绘制不同的图形，方法的重写会覆盖父类的方法，在子类调用重写的方法会默认为子类重写的方法，而不会调用父类的方法。方法之间可以互相调用。而方法的重载，是在同一个类中对同一个方法，但是参数不同的方法进行重写，这两个概念不要混淆。方法的调用遵循就近原则。

3,程序中只有类，属性，和方法，所以修饰符就是修饰这三个，访问修饰符表示一种权限，访问修饰符有pravate（私有的）只有该类可以访问、protect（保护的）只有该类及其子类的成员可以访问，同一个包中的类也可以访问，public（公共的）该类或者非该类均可以访问，默认（相同数据包中的类可以访问）。类一般使用公共的。构造方法一般在单例模式下使用私有的。否则使用共有的。

定义人类Person, （1）字段：身份证号idCard，姓名name,性别gender，年龄age，职业profession，联系方式phone。并定义相应的属性；（2）定义函数message()输出个人的基本信息（3）定义默认的构造函数,并打印一句话，输出“我是人类”。

定义一个教师类Teacher,派生于人类；（a）具有字段：职工号wordID，所教授的课程名curriculum ,所属院系academy,并定义相应的属性（b）重写构造函数。（c）定义一个普通方法teach（）,输出我是教学的。

----------- 定义一个数学教师类MathTeacher,派生于教师类；（a）重写父类的teach();输出我是从事数学教学的。（b）重写默认构造函数。再写一个带参数的构成函数 MathTeacher（String name）（c）有两个重载方法，ready（），ready（String scource）;

定义一个英语教师类EnglishTeacher,派生于教师类；（a）重写父类的teach();输出我是从事英语教学的。（b）重写默认构造函数。再写一个带参数的构成函数 EnglishTeacher（String name），并显示的调用父类的构成方法（c）有两个重载方法，write（），write（String scource）;

package com.pojo;

public class Person {
    public long IdCard;
    public String name;
    public boolean gender;
    public int age;
    public String profession;
    public String  phone;
    public void message(){
        System.out.println("输出个人基本信息");
    }
    public Person(){
        System.out.println("我是人类");
    }
    public static void main(String []args){
        MathTeacher mathTeacher=new MathTeacher("zhangsan");
        System.out.println("个人基本信息");
    }
}    
class Teacher extends Person{
    public String wordID;
    public String curriculum;
    public String academy;
    public Teacher(){
        this.name="王麻子";
        this.IdCard=12;
        this.gender=true;
        this.age=35;
        this.profession="英语教师";
        this.phone="13532452473";
        System.out.println("我是教师");
    }
    public void teach(){
        System.out.println("我是教学的");
    }
}
class MathTeacher extends Teacher{
    public void teach(){
        System.out.println("我是从实输血教学的");
    }
    public MathTeacher(String name){
        this.name=name;
        this.IdCard=12;
        this.gender=false;
        this.age=45;
        this.profession="数学教师";
        this.phone="12354452473";
        System.out.println(name+IdCard+gender+age+profession+phone);
    }
    public void ready(){
        System.out.println("我在教学生读");
    }
    public void ready(String scource){
        System.out.println("在教一个学生");
    }
}
class EnglishTeacher extends Teacher{
    public void teach(){
        System.out.println("我是从事英语教学的");
    }
    public EnglishTeacher(){
        System.out.println("卧室英语教师");
    }
    public EnglishTeacher(String name){
        this.name="李四";
        System.out.println("我是李思老师");
    }
    public void write(){
        System.out.println("我在教学生们写");
    }
    public void write(String scource){
        System.out.println("我在教一个学生写");
    }
}

5,方法修饰符有static（静态的，不能修饰类。可以修饰属性和方法）。作用：用static修饰的属性在内存中会占用固定的内存空间。不会隶属任何一个实例对象。所有的实例对象都共享这个变量，类似全局变量，比较节省内存，但是这个内存空间要在程序执行完了之后才会消失，。一般静态变量都使用类名访问，不使用对象去访问。使用类名去访问是因为静态的是共享的，static也可以修饰方法，叫静态方法，静态方法只能访问静态变量，直接使用类名访问，还可以修饰一段代码static{ . 。。。。}，让他是静态的，称为语句块，这个静态语句块会比main运行之前运行，但是只会运行一次。 final（最终的），不可改变的，修饰类，属性，方法，不能用类名访问，只能访问，不能修改，修饰方法的特点：不能用类名直接访问，一般和普通方法没什么区别，但是只对子类有用，子类继承的时候不能重写父类的方法。修饰类的时候，该类不可以被继承。俗称太监类。；常量一般使用全大写，属性首字母小写，驼峰式命名，这是命名规范。 abstract（抽象的）对类抽象，说明该类不可以被new，一般具有抽象的类就用该关键字来修饰，防止被抽象化的类被实例化，因为抽象没有意义，如人类。方法也可以别抽象化，如果一个方法必须要子类实现，就要把该方法抽象定义为一个抽象方法。抽象方法没有方法体。

6.接口（interface）.接口就是某个事物对外提供的一些功能的说明。可以利用接口实现多态，同时接口也弥补了java单一继承的弱点。接口使用interface关键字定义接口，一般使用接口声明方法或常量，接口中的方法只能是声明，不能是具体的实现（就是没有方法体）。实现接口用关键字implements .实现就一定要实现接口的方法和常量，接口可以实现多个，一个类实现一个接口或者多个接口，并且还可以继承其他类。

1、定义抽象类员工Employee, （1）保护字段：姓名name,性别gender，年龄age等基本属性。（2）定义抽象方法函数getsalary()表示领工资的操作（3）定义普通函数whoami()输出：我是+姓名（4）拥有（姓名name,性别gender）参数的构造函数（5）使用常量定义员工的三个状态：离职=0；在职=1；试用期=2

定义一个经理类Manager 派生于员工；（a）除了有员工等基本属性外，还有岗位级别 gree私有属性（b）经理领7000元工资，打印并输出工资。（c）重写父类的whoami(),调用父类的whoami()方法，再输出：我是一名经理。

定义一个会计类Technician,派生于员工类；（a）除了有员工等基本属性外，还有会计等级 rating私有属性（b）会计领3000元工资，打印并输出工资。（c）重写父类的whoami(),调用父类的whoami()方法，再输出：我是一名会计。

public abstract class Employee {
    private String name;
    private int age;
    public abstract void getsalary();
    public void whoami() {
        System.out.println("我是："+name+age);
    }
    public Employee(String name,int age){
        
    }
    int ZTLZ=0;
    int ZTZZ=1;
    int ZTSY=2;
}
class Manager extends Employee{
    public Manager(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }
    private int gree;
    public  void getsalary(){
        System.out.println("领工资：7000");
    }
    public void whoami(){
        System.out.println("我是一名经理"+gree);
        
    }
    
}
class Technician extends Employee{
    public Technician(String name, int age) {
        super(name, age);
        
        // TODO Auto-generated constructor stub
    }
    public void getsalary(){
        System.out.println("会计领取工资3000元");
    }
    public void whoami(){
        System.out.println("我是一名会计"+rating);
    }

    private int rating;
}

2、、定义一个计算器接口Cal 有一个方法：int opetator（int a，int b）；

定义一个类Add实现这个接口，计算两个数的和

定义一个类Mul实现这个接口，计算两个数的积

定义一个类Mod实现这个接口，计算两个数的模

写一个Run类，测试运行

public class Run {
    public static void main(String[]args){
        int a=4;
        int b=2;
        Cal cal=new Mul();
        int jieguo=cal.opetator(a, b);
        System.out.println(jieguo);
    }

    

}

public interface Cal {
    int opetator(int a,int b);

}
class Add implements Cal{

    @Override
    public int opetator(int a, int b) {
        // TODO Auto-generated method stub
        return a+b;
    }
    
}
class Mul implements Cal{

    @Override
    public int opetator(int a, int b) {
        // TODO Auto-generated method stub
        return a*b;
    }
    
}
class Mod implements Cal{

    @Override
    public int opetator(int a, int b) {
        // TODO Auto-generated method stub
        return a/b;
    }
    
}

继承 多态 封装

继承多态封装