Java面向对象--接口和多态

final 关键字

最终修饰符 可以修饰 类 方法 变量

被final修饰后不能被继承 重写 二次赋值

修饰类时 该类不可以被继承

修饰方法时 该方法不能被重写

修饰变量时, 该变量只能赋值一次, 不可以二次赋值 是常量

修饰引用变量时, 地址值不能改变 但对象中的属性值可以改变

修饰成员变量时, 必须在类中显性赋值 或 在所有构造方法中对其赋值

接口

接口是功能的集合 描述的是功能 接口中都是抽象方法(JDK1.8之前)

定义格式

public interface 接口名{
	抽象方法;
}

接口的使用

1.接口不能创建对象

2.使用类实现接口

3.重写抽象方法

4.创建实现类对象 调用方法

实现的动作类似继承 就是关键字不同

public class 类  implements 接口{
	重写方法
}

接口的成员特点

接口没有构造方法

接口中的成员变量 被public static final修饰 是常量

接口中的成员方法 被public abstract修饰

接口的特点

类与类 单继承

类与接口 多实现

接口与接口 多继承

类可以在继承一个类的同时 实现多个接口

接口与抽象类的区别

成员区别
	构造方法
		接口没有构造方法
		抽象类有构造方法 给子类使用
	成员变量
		接口没有变量 只有常量
		抽象类既可以有变量 也可以有常量
	成员方法
		接口中的方法都是抽象的
		抽象类中 既可以有抽象方法 也可以有具体的方法
	思想的区别
		抽象类描述的是一类事物的共性内容
		接口描述的是功能

多态

多态的前提

1.继承或者是实现关系

2.需要有方法重写

多态的格式

父类引用指向子类对象

具体类  变量 = new 子类对象();
抽象类  变量 = new 子类对象();
接口  变量 = new 实现类对象();

多态后访问的成员特点

成员变量
	编译时 到父类中找 如果有编译通过 没有报错
	运行时  打印的父类成员变量的值
	编译时  看左边
	运行时  看左边
成员方法
	编译时 到父类中找 如果有编译通过 没有报错
	运行时  子类重写后的方法
	编译时 看左边
	运行时 看右边
多态后 一切都是父类的表现形式 只有方法运行的子类重写后的方法.

向上转型和向下转型

// 向上转型
// 多态本身就是向上转型
Fu fz = new Zi();
// 向下转型
// 向上转型后 不能访问子类特有功能
// 要想访问 需要向下转型
Zi zf = (Zi)fz;

// 需要注意
Fu fu = new fu();
Zi  zi = (Zi)fu; //抛运行时异常  ClassCastException 类型转换异常

instanceof关键字

判断某个对象是否属于某种类型 是返回true, 否返回false

boolean b = 对象 instanceof 类型;
if(对象 instanceof 类型){}

练习

员工类
	属性
		id
		name
		基本工资
	行为
		计算工资  抽象

经理类
	属性
		id
		name
		基本工资
		管理工资
	行为
		计算工资  基本工资+管理工资
程序员
	属性
		id
		name
		基本工资
		项目奖金
	行为
		计算工资  基本工资+项目奖金

公司类
	行为
		查看员工工资(员工){
			员工的工号:38250
			员工的姓名:柳岩
			员工的职位:经理
			员工的工资:11111.00
		}

练习

// Employee.java
public abstract class Employee {
    String id;
    String name;
    private double salary;

    public Employee() {
    }

    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public abstract double calculateSalary();

    public String getName() {
        return name;
    }

    public double getSalary(){
        return salary;
    }
}

// Manager.java
public class Manager extends Employee{
    private double additionalSalary;

    public Manager() {
    }

    public Manager(String id, String name, double salary, double additionalSalary) {
        super(id, name, salary);
        this.additionalSalary = additionalSalary;
    }

    public double getAdditionalSalary() {
        return additionalSalary;
    }

    public void setAdditionalSalary(double additionalSalary) {
        this.additionalSalary = additionalSalary;
    }

    @Override
    public double calculateSalary() {
        return super.getSalary() + getAdditionalSalary();
    }
}

// Programmer.java
public class Programmer extends Employee{
    private double projectSalary;

    public double getProjectSalary() {
        return projectSalary;
    }

    public Programmer() {
    }

    public Programmer(String id, String name, double salary, double projectSalary) {
        super(id, name, salary);
        this.projectSalary = projectSalary;
    }

    public void setProjectSalary(double projectSalary) {
        this.projectSalary = projectSalary;
    }

    @Override
    public double calculateSalary() {
        return super.getSalary() + getProjectSalary();
    }
}

// Company.java
public class Company {
    public void lookEmployeeSalary(Employee employee) {
        String position = "员工";
        if (employee instanceof Manager) {
            position = "经理";
        } else if (employee instanceof Programmer){
            position = "程序员";
        }
        System.out.println("员工的工号: " + employee.id);
        System.out.println("员工的姓名: " + employee.name);
        System.out.println("员工的职位: " + position);
        System.out.println("员工的工资: " + employee.calculateSalary());
    }
}

public class Demo {
    public static void main(String[] args) {
        Company company = new Company();
        company.lookEmployeeSalary(new Manager("001", "经理一号",20000, 3000));
        System.out.println("============================");
        company.lookEmployeeSalary(new Programmer("002", "程序员一号",20000, 3000));

    }
}