1.abstract:抽象的
2.abstract可以用来修饰的结构：类、方法
3.abstract修饰类：抽象类
此类不能实例化
抽象类中一定有构造器，
便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
4.abstract修饰方法：抽象方法
抽象方法只有方法的声明，没有方法体
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
abstract不能去修饰方法和构造器
abstract不能修饰静态方法、私有方法、final方法、final类
练习编写一个Employee类，声明为抽象类，
包含如下三个属性：name,id,salary。
提供必要的构造器和抽象方法：wok()
对于Manager类来说，他既是员工，还具有奖金(bonus))的属性。
请使用继承的思想，设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问。
抽象父类Employee
public abstract class Employee {
private String name;
private int id;
private int salary;
public Employee(String name, int id, int salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
public abstract void work();
}
子类CommonEmployee
public class CommonEmployee extends Employee{
public CommonEmployee(String name, int id, int salary) {
super(name, id, salary);
}
@Override
public void work() {
System.out.println("普通员工正在工作...");
}
}
子类Manager
public class Manager extends Employee{
private int bonus;
public Manager(String name, int id, int salary, int bonus) {
super(name, id, salary);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("我是经理，我正在工作...我的奖金是："+bonus);
}
}
练习二
编写工资系统，实现不同类型员工（多态）的按月发放工资。如果当月出现某个
Employee对象的生日，则将该雇员的工资增加100元。
实验说明：
(1)定义一个Employee类，该类包含：
private成员变量name,number,birthday,其中birthday为yDate类的对象；
abstract方法earnings():
toString()方法输出对象的name,number和birthday。
(2)MyDate类包含：
private成员变量year,month,day;
toDateString()方法返回日期对应的字符串：Xxxx年xx月x日
(3)定义SalariedEmployee类继承Employee:类，实现按月计算工资的员工处
理。该类包括：private成员变量monthlySalary;
实现父类的抽象方法earnings(),该方法返回monthlySalary值；toString()方法输
出员工类型信息及员工的name,number,birthday。
(4)参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的
员工处理。该类包括：
private成员变量wage和hour;
实现父类的抽象方法earnings(),该方法返回wage*hour值；
toString()方法输出员工类型信息及员工的name,number,birthday。
(5)定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各
类雇员对象的引用。利用循环结构遍历数组元素，输出各个对象的类
型，name,number,birthday.,以及该对象生口。当键盘输入本月月份值时，如果本
月是某个Employee对象的生口，还要输出增加工资信息。
public abstract class Employee {
private String name;
private int number;
private MyDate birthday;
public abstract int earning();
public Employee(String name, int number, MyDate birthday) {
this.name = name;
this.number = number;
this.birthday = birthday;
}
public MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + ''' +
", number=" + number +
", birthday=" + birthday.toDateString() +
'}';
}
}
public class MyDate {
private int year;
private int month;
private int day;
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public String toDateString() {
return year+"年"+month+"月"+day+"日";
}
}
public class SalariedEmployee extends Employee{
private int monthlySalary;
public SalariedEmployee(String name, int number, MyDate birthday) {
super(name, number, birthday);
}
public SalariedEmployee(String name, int number, MyDate birthday, int monthlySalary) {
super(name, number, birthday);
this.monthlySalary = monthlySalary;
}
@Override
public int earning() {
return monthlySalary;
}
public String toString() {
return super.toString();
}
}
public class HourlyEmployee extends Employee{
private int wage;
private int hour;
public HourlyEmployee(String name, int number, MyDate birthday) {
super(name, number, birthday);
}
public HourlyEmployee(String name, int number, MyDate birthday, int wage, int hour) {
super(name, number, birthday);
this.wage = wage;
this.hour = hour;
}
@Override
public int earning() {
return wage*hour;
}
public int getWage() {
return wage;
}
public void setWage(int wage) {
this.wage = wage;
}
public int getHour() {
return hour;
}
public void setHour(int hour) {
this.hour = hour;
}
public String toString() {
return super.toString();
}
}
public class PayrollSystem {
public static void main(String[] args) {
//获取月份方式一
// Scanner scanner = new Scanner(System.in);
// System.out.println("请入当前月份：");
// int month=scanner.nextInt();
//获取月份方式二
Calendar instance = Calendar.getInstance();
int month = instance.get(Calendar.MONTH);
month++;
Employee[] employees = new Employee[2];
employees[0] = new SalariedEmployee("zs",1001,new MyDate(2001,7,5),13000);
employees[1] = new HourlyEmployee("ls",1002,new MyDate(2001,5,5),240,60);
for (int i = 0; i < employees.length; i++) {
System.out.println(employees[i].toString());
if(employees[i].getBirthday().getMonth()==month){
int earning = employees[i].earning();
System.out.println("工资为"+(earning+100));
}
}
}
}
接口的使用
1.接口使用interface来定义
2.Java中，接口和类是并列的两个结构
3.如何定义接口：定义接口中的成员
3.1JDK7及以前：只能定义全局常量和抽象方法
全局常量：public static final的.但是书写时，可以省略不写
抽象方法：public abstract的
3.2JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
4.接口中不能定义构造器的！意味着接口不可以实例化
5.Java开发中，接口通过让类去实现(implements)的方式来使用.
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6.Java类可以实现多个接口—>弥补了Java单继承性的局限性
格式：class AA extends BB implements CC,DD,EE
7.接口与接口之间可以继承，而日可以多继承
8.接口的具体使用，体现多态性
9.接口实际上可以看成是一个规范
接口使用也满足多态性
接口，实际上就定义了一种规范
开发中，体会面向接口编程
面试题：抽象类与接口有哪些异同代理模式
public interface Star {
void confer();//面谈
void signContract();//签合同
void bookTicket();//订票
void sing();//唱歌
void pay();//给钱
}
public class RealStar implements Star {
@Override
public void confer() {
}
@Override
public void signContract() {
}
@Override
public void bookTicket() {
}
@Override
public void sing() {
System.out.println("高有道唱模拟他....");
}
@Override
public void pay() {
}
}
public class ProxyStar implements Star{
private Star star;
public ProxyStar(Star star) {
this.star = star;
}
@Override
public void confer() {
System.out.println("经纪人面试");
}
@Override
public void signContract() {
System.out.println("经纪人签合同");
}
@Override
public void bookTicket() {
System.out.println("经纪人订票");
}
@Override
public void sing() {
star.sing();
}
@Override
public void pay() {
System.out.println("经纪人收款");
}
}
public class ProxyTest {
public static void main(String[] args) {
ProxyStar proxyStar = new ProxyStar(new RealStar());
proxyStar.confer();
proxyStar.signContract();
proxyStar.bookTicket();
proxyStar.sing();
proxyStar.pay();
}
}
知识点1：接口中定义的静态方法，只能通过接口来调用
知识点2：通过实现类对象可以调用接口中默认的方法
如果实现类重写了接口中的方法，调用时，仍然调用重写后的方法
知识点3：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写的情况下，默认调用的是父类中同名同参数的方法
类优先原则
知识点4：如果子类（或实现类）继承了多个接口，而多个接口中定义了同名同参数的方法，在没有重写的情况下将会报错，----》接口冲突
这就需要我们必须在实现类中重写此方法
知识点5：如何在子类（或实现类）的方法中调用父类接口中被重写的方法
super.method()；//父类
//调用接口中的默认方法
子类.super.方法（）；
内部类类的内部成员之五：内部类
1ava中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
2,内部类的分类：成员内部类（静态、非静态）VS局部内部类（方法内、代码块内、构造器内）
3.成员内部类：
一方面，作为外部类的成员：
调用外部类的结构
可以被static修饰
可以被4种不同的权限修饰
另一方面，作为一个类：
类内可以定义属性、方法、构造器等
可以被Final修饰，表示此类不能被继承。言外之意，不使用final,就可以被继承
可以被abstract修饰
4.关注如下的3个问题
4.1如何实例化成员内部类的对象
4.2如何在成员内部类中区分调用外部类的结构
4.3开发中局部内部类的使用:返回一个实现了XXX接口的类的对象
public class Person {
private String name;
private int age;
class man{
public void hello(){
System.out.println("你好！！！！");
System.out.println(name);
System.out.println(Person.this.name);
}
}
static class woman{
private String name;
public void method(){
System.out.println("method1....");
}
}
public static void main(String[] args) {
//非静态内部类
Person person = new Person();
man man = person.new man();
man.hello();
//静态内部类
Person.woman woman=new Person.woman();
woman.method();
}
public Comparable getComparable(){
//方式1
//方式二
return new Comparable() {
@Override
public int compareTo(Object o) {
return 0;
}
};
}
}
