黑马程序员—JAVA基础—多态、抽象类、接口、修饰符
2015-11-26 22:46
639 查看
-----------android培训、java培训、java学习型技术博客、期待与您交流!------------
一、多态
1、概念:
同一个对象在不同时刻体现出来的不同状态。2、多态的前提:
A:有继承或者实现关系。B:有方法重写。
C:有父类或者父接口引用指向子类对象。
3、多态的分类:
A:具体类多态B:抽象类多态
C:接口多态
4、多态中的成员访问特点:
A:成员变量编译看左边,运行看左边
B:构造方法:
子类的构造都会默认访问父类构造
C:成员方法:
编译看左边,运行看右边
D:静态方法:
编译看左边,运行看左边
5、多态的优点:
A:提高代码的维护性(继承体现)B:提高代码的扩展性(多态体现)
6、多态的缺点:
A:父不能使用子的特有功能。现象:子可以当作父使用,父不能当作子使用。
7、多态中的转型:
A:向上转型:从子到父B:向下转型:从父到子
Eg:
/* 看程序写结果:先判断有没有问题,如果没有,写出结果 多态的成员访问特点: 方法:编译看左边,运行看右边。 继承的时候: 子类中有和父类中一样的方法,叫重写。 子类中没有父亲中出现过的方法,方法就被继承过来了。 */ class A { public void show() { show2(); } public void show2() { System.out.println("我"); } } class B extends A { /* public void show() { show2(); } */ public void show2() { System.out.println("爱"); } } class C extends B { public void show() { super.show(); } public void show2() { System.out.println("你"); } } public class DuoTaiTest4 { public static void main(String[] args) { A a = new B(); a.show(); B b = new C(); b.show(); } }</span>
二、抽象类
1、概念:
用关键字abstract修饰的类称为抽象类.注意事项:
A:而一个没有具体的方法体的方法是抽象的方法。B:在一个类中如果有抽象方法,该类必须定义为抽象类。
2、抽象类的特点
A:抽象类和抽象方法必须用关键字abstract修饰B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
D:抽象类的子类
a:可以是一个抽象类。
b:可以是一个具体类。但是这个类必须重写抽象类中的所有抽象方法。
3、抽象类的成员特点:
A:成员变量有变量,有常量
B:构造方法
有构造方法
C:成员方法
有抽象,有非抽象
4、注意事项:
A:抽象类有构造方法,不能直接实例化,通过子类间接实例化。B:一个类如果没有抽象方法,却定义为了抽象类,作用:为了不让创建对象
C:abstract不能和哪些关键字共存
a:final 冲突
b:private 冲突
c:static 无意义
Eg:
/* 假如在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。 经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。 请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。 分析: 普通员工类 成员变量:姓名、工号以及工资。 成员方法:工作 经理类: 成员变量:姓名、工号以及工资,奖金属性 成员方法:工作 实现: 员工类: 普通员工类: 经理类: */ //定义员工类 abstract class Employee { //姓名、工号以及工资 private String name; private String id; private int salary; public Employee() {} public Employee(String name,String id,int salary) { this.name = name; this.id = id; this.salary = salary; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getId() { return id; } public void setId(String id) { this.id = id; } public int getSalary() { return salary; } public void setSalary(int salary) { this.salary = salary; } //工作 public abstract void work(); } //普通员工类 class Programmer extends Employee { public Programmer(){} public Programmer(String name,String id,int salary) { super(name,id,salary); } public void work() { System.out.println("按照需求写代码"); } } //经理类 class Manager extends Employee { //奖金 private int money; //bonus 奖金 public Manager(){} public Manager(String name,String id,int salary,int money) { super(name,id,salary); this.money = money; } public void work() { System.out.println("跟客户 4000 谈需求"); } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } } class AbstractTest4 { public static void main(String[] args) { //测试普通员工 Employee emp = new Programmer(); emp.setName("张三"); emp.setId("czbk001"); emp.setSalary(18000); System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary()); emp.work(); System.out.println("-------------"); emp = new Programmer("张三","czbk001",18000); System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary()); emp.work(); System.out.println("-------------"); /* emp = new Manager(); emp.setName("李四"); emp.setId("czbk002"); emp.setSalary(8000); emp.setMoney(2000); */ //由于子类有特有的内容,所以我们用子类来测试 Manager m = new Manager(); m.setName("李四"); m.setId("czbk002"); m.setSalary(8000); m.setMoney(2000); System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney()); m.work(); System.out.println("-------------"); //通过构造方法赋值 m = new Manager("李四","czbk002",8000,2000); System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney()); m.work(); } }
三、:接口
1、概述:
接口可以理解成一种特殊的类,是由用final修饰的常量(自定义常量)和公共的抽象方法组成的类;2:接口的特点:
A:接口用关键字interface修饰interface 接口名 {}
B:类实现接口用implements修饰
class 类名 implements 接口名 {}
C:接口不能实例化
D:接口的实现类
a:可以是一个抽象类。
b:可以是一个具体类,这个类必须重写接口中的所有抽象方法。
3、接口的成员特点:
A:成员变量a: 只能是常量
b: 默认修饰符:public static final
B:构造方法
没有构造方法
C:成员方法
a: 只能是抽象的
b: 默认修饰符:public abstract
4、类与类,类与接口,接口与接口
A:类与类继承关系,只能单继承,可以多层继承
B:类与接口
a:实现关系,可以单实现,也可以多实现。
b:可以在继承一个类的同时,实现多个接口
C:接口与接口
继承关系,可以单继承,也可以多继承
Eg:
/<span style="font-family:Arial Black;">* 老师和学生案例,加入抽烟的额外功能 分析:从具体到抽象 老师:姓名,年龄,吃饭,睡觉 学生:姓名,年龄,吃饭,睡觉 由于有共性功能,提取出一个父类,人类。 人类: 姓名,年龄 吃饭(); 睡觉(){} 抽烟的额外功能不是人或者老师,或者学生一开始就应该具备的,所以,把它定义为接口 抽烟接口。 部分老师抽烟:实现抽烟接口 部分学生抽烟:实现抽烟接口 实现:从抽象到具体 使用:具体 */ //定义抽烟接口 interface Smoking { //抽烟的抽象方法 public abstract void smoke(); } //定义抽象人类 abstract class Person { //姓名 private String name; //年龄 private int age; public Person() {} public Person(String name,int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } //吃饭(); public abstract void eat(); //睡觉(){} public void sleep() { System.out.println("睡觉觉了"); } } //具体老师类 class Teacher extends Person { public Teacher() {} public Teacher(String name,int age) { super(name,age); } public void eat() { System.out.println("吃大白菜"); } } //具体学生类 class Student extends Person { public Student() {} public Student(String name,int age) { super(name,age); } public void eat() { System.out.println("吃红烧肉"); } } //抽烟的老师 class SmokingTeacher extends Teacher implements Smoking { public SmokingTeacher() {} public SmokingTeacher(String name,int age) { super(name,age); } public void smoke() { System.out.println("抽烟的老师"); } } //抽烟的学生 class SmokingStudent extends Student implements Smoking { public SmokingStudent() {} public SmokingStudent(String name,int age) { super(name,age); } public void smoke() { System.out.println("抽烟的学生"); } } class InterfaceTest2 { public static void main(String[] args) { //测试学生 SmokingStudent ss = new SmokingStudent(); ss.setName("张三"); ss.setAge(27); System.out.println(ss.getName()+"---"+ss.getAge()); ss.eat(); ss.sleep(); ss.smoke(); System.out.println("-------------------"); SmokingStudent ss2 = new SmokingStudent("李四",28); System.out.println(ss2.getName()+"---"+ss2.getAge()); ss2.eat(); ss2.sleep(); ss2.smoke(); } }</span>
四、抽象类和接口的区别
A:成员区别
抽象类:可以使常量;也可以是变量接口:只能是用final修饰的常量
B:关系区别:
类与类: a:可以是一个抽象类。b:可以是一个具体类。但是这个类必须重写抽象类中的所有抽象方法。
类与接口: a:实现关系,可以单实现,也可以多实现。
b:可以在继承一个类的同时,实现多个接口
接口与接口:继承关系,可以单继承,也可以多继承
C:设计理念不同
抽象类:is a,抽象类中定义的是共性功能。接口:like a,接口中定义的是扩展功能。
五、常见的修饰符
A:分类:
权限修饰符:private,默认,protected,public状态修饰符:static,final
抽象修饰符:abstract
B:常见的类及其组成的修饰
类: 默认,public,final,abstract常用的:public
成员变量: private,默认,protected,public,static,final
常用的: private
构造方法: private,默认,protected,public
常用的: public
成员方法: private,默认,protected,public,static,final,abstract
常用的: public
C:另外比较常见的:
public static final int X = 10;public static void show() {}
public final void show() {}
public abstract void show();
七、权限修饰符
(Y代表可以访问) | 本类 | 同一个包下 | 不同包下的子类 | 不同包下的无关类 |
private | Y | | | |
默认 | Y | Y | | |
protected | Y | Y | Y | |
public | Y | Y | Y | Y |