标签：Java
1.1 抽象类概述package com.itheima_01;
/*
* abstract:关键字，用于修饰方法和类
* 抽象方法：不同类的方法是相似，但是具体内容又不太一样，所以我们只能抽取他的声明，没有具体的方法体，没有具体方法体的方法就是抽象方法
* 抽象类：有抽象方法的类必须是抽象类
*
* 注意：一个类继承了抽象类需要重写他所有的抽象方法,否则这个类就得是抽象类
*/
public class AbstractDemo {
}
abstract class Animal1 {
public abstract void eat();
//非抽象方法子类可以不重写
public void run() {
}
}
class Cat1 extends Animal1 {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
/*public void eat() {
System.out.println("猫吃鱼");
}*/
}
abstract class Dog1 extends Animal1 {
/*public void eat() {
System.out.println("狗吃屎");
}*/
}1.2 抽象类的特点
抽象类的特点：
抽象方法只能在抽象类里面
抽象类和抽象方法必须被abstract修饰
抽象类不能创建对象（不能实例化）
抽象类中可以有非抽象的方法
抽象类和类的关系也是继承
一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类
1.2.1 案例代码十二
package com.itheima_01;
/*
* 抽象类的特点：
* 抽象方法只能在抽象类里面
* 抽象类和抽象方法必须被abstract修饰
* 抽象类不能创建对象（不能实例化）
* 抽象类中可以有非抽象的方法
* 抽象类和类的关系也是继承
* 一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类
*/
public class AbstractDemo2 {
public static void main(String[] args) {
//Animal a = new Animal();
}
}
abstract class Animal2 {
public abstract void eat();
public void run() {
}
}
class Cat2 extends Animal2 {
@Override
public void eat() {
// TODO Auto-generated method stub
}
}1.3 抽象类的成员的特点
A:抽象类的成员特点：
成员变量
可以有成员变量
可以有常量
成员方法
可以有抽象方法
可以有非抽象方法
构造方法
可以有构造方法的，需要对抽象类的成员变量进行初始化
1.3.1 案例代码十三
package com.itheima_01;
/*
* 抽象类的成员特点：
* 成员变量
* 可以有成员变量
* 可以有常量
* 成员方法
* 可以有抽象方法
* 可以有非抽象方法
* 构造方法
* 可以有构造方法的，需要对抽象类的成员变量进行初始化
*
* final:修饰类、成员变量、成员方法
*/
public class AbstractDemo3 {
public static void main(String[] args) {
Dog d = new Dog();
d.barking();
}
}
abstract class Animal {
String name = "哮天犬";
final int num = 10;
public Animal() {
System.out.println("我是抽象类的构造方法");
}
public abstract void eat();
public void run() {}
}
class Dog extends Animal {
public void barking() {
System.out.println(name);
System.out.println(num);
}
@Override
public void eat() {
// TODO Auto-generated method stub
}
}1.4 抽象类案例
1.4.1 老师案例:
老师类:
属性:姓名,年龄,性别
行为:讲课
基础班老师:
属性:姓名,年龄,性别
行为:讲基础班课程
就业班老师:
属性:姓名,年龄,性别
行为:讲就业班课程
1.4.1.1 案例代码十四
//测试类
package com.itheima_04;
/*
* 基础班老湿，就业班老湿
共性
属性 姓名，年龄，性别
行为 讲课
*
*/
public class AbstractTest {
public static void main(String[] args) {
//创建的基础班老湿对象
BasicTeacher bt = new BasicTeacher();
//为老湿对象的成员变量进行赋值
bt.setName("风清扬");
bt.setAge(50);
bt.setGender("男");
bt.teach();
//创建就业班老湿对象
JobTeacher jt = new JobTeacher();
//为老湿对象的成员变量进行赋值
jt.setName("苍老师");
jt.setAge(18);
jt.setGender("女");
jt.teach();
}
}
package com.itheima_04;
//老师类
public abstract class Teacher {
private String name;//姓名
private int age;//年龄
private String gender;//性别
public Teacher() {
super();
// TODO Auto-generated constructor stub
}
public Teacher(String name, int age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
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 String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public abstract void teach();
}
package com.itheima_04;
//基础班老师类
public class BasicTeacher extends Teacher {
@Override
public void teach() {
System.out.println(getName() + "讲基础班课程");
}
}
package com.itheima_04;
//就业班老师类
public class JobTeacher extends Teacher{
@Override
public void teach() {
System.out.println(getName() + "讲就业班课程");
}
}1.4.2 员工案例
雇员类:
属性:姓名,编号,薪水
行为:工作
程序员:
属性:姓名,编号,薪水
行为:写代码工作
经理:
属性:姓名,编号,薪水,奖金
行为:盯着程序员写代码工作
1.4.2.1 案例代码十五
//测试类
package com.itheima_05;
/*
* 员工(Employee)示例：
需求：
公司中
程序员(Programmer)有姓名(name)，工号(id)，薪水(pay)，工作(work)。
项目经理(Manager)除了有姓名(name)，工号(id)，薪水(pay)，工作(work)，还有奖金(bonus)。
共性
属性 姓名，工号，薪水
行为 工作
*/
public class AbstractTest2 {
public static void main(String[] args) {
//创建程序员对象
Programmer p = new Programmer();
p.setName("张三");
p.setId("002");
p.setPay(10000);
p.work();
//创建项目经理的对象
Manager m = new Manager();
m.setName("比尔盖茨");
m.setId("001");
m.setPay(0);
m.setBonus((byte)100);
m.work();
}
}
//员工类package com.itheima_05;
public abstract class Employee {
private String name;//姓名
private String id;//工号
private double pay;//薪水
public Employee() {
super();
// TODO Auto-generated constructor stub
}
public Employee(String name, String id, double pay) {
super();
this.name = name;
this.id = id;
this.pay = pay;
}
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 double getPay() {
return pay;
}
public void setPay(double pay) {
this.pay = pay;
}
public abstract void work();
}
//程序员类package com.itheima_05;
public class Programmer extends Employee {
@Override
public void work() {
System.out.println(getName() + "正在写代码...");
}
}
//项目经理类package com.itheima_05;
public class Manager extends Employee{
private byte bonus;
public byte getBonus() {
return bonus;
}
public void setBonus(byte bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println(getName() + "正在盯着程序员写代码...");
}
}1.4.3 技师案例
技师:
属性:姓名,年龄
行为:服务
足疗技师:
属性:姓名,年龄
行为:按按脚揉揉肩
其它技师:
属性:姓名,年龄
行为:你懂的
1.4.3.1 案例代码十六
//测试类
package com.itheima_06;
/*
* 足疗店
* 技师
* 足疗技师
* 其他技师
* 共性
* 属性 姓名，年龄
* 行为 服务
*/
public class AbstractTest3 {
public static void main(String[] args) {
//创建足疗技师的对象
足疗技师 zl = new 足疗技师();
zl.service();
//创建其他技师对象
其他技师 qt = new 其他技师();
qt.service();
}
}
//技师类package com.itheima_06;
public abstract class 技师 {
private String name;//姓名
private int age;//年龄
public 技师() {
super();
// TODO Auto-generated constructor stub
}
public 技师(String name, int age) {
super();
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 service();
}
//足疗技师类package com.itheima_06;
public class 足疗技师 extends 技师{
@Override
public void service() {
System.out.println("揉揉肩按按腰捏捏脚");
}
[align=left]}
//其它技师类package com.itheima_06;
public class 其他技师 extends 技师{
@Override
public void service() {
System.out.println("你懂的");
}
}1.5 抽象类的细节
A:抽象类关键字abstract可以和哪些关键字共存?
1.private：
私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
2.final:
抽象类不能和final共存,因为抽象类自身无法创建对象,我们需要通过子类创建对象,一旦抽象类使用final关键字,那么抽象类就没有子类
抽象方法不能和final共存,因为抽象方法后期需要被子类重写,一旦加final无法重写
3.static:
抽象方法不能和static关键字共存,因为一旦加static我们就可以通过类名直接访问抽象方法,由于抽象方法没有方法体,没有任何意义,也不允许这样做
B:抽象类中是否可以不定义抽象方法?
是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
C:抽象类是否有构造函数?
有,抽象类的构造函数,是由子类的super语句来调用,用于给抽象类中的成员初始化
标签：Java
原文地址：http://blog.51cto.com/13517854/2094115
