java抽象类基础入门.docx
《java抽象类基础入门.docx》由会员分享，可在线阅读，更多相关《java抽象类基础入门.docx（24页珍藏版）》请在冰豆网上搜索。
java抽象类基础入门
1抽象类概述
/*
抽象类的概述：
动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。
我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。
抽象类的特点：
A:
抽象类和抽象方法必须用abstract关键字修饰
B:
抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
C:
抽象类不能实例化
因为它不是具体的。
抽象类有构造方法，但是不能实例化?
构造方法的作用是什么呢?
用于子类访问父类数据的初始化
D:
抽象的子类
a:
如果不想重写抽象方法，该子类是一个抽象类。
b:
重写所有的抽象方法，这个时候子类是一个具体的类。
抽象类的实例化其实是靠具体的子类实现的。
是多态的方式。
Animala=newCat（）;
*/
//abstractclassAnimal//抽象类的声明格式
abstractclassAnimal{
//抽象方法
//publicabstractvoideat（）{}//空方法体,这个会报错。
抽象方法不能有主体
publicabstractvoideat（）;
publicAnimal（）{}
}
//子类是抽象类
abstractclassDogextendsAnimal{}
//子类是具体类，重写抽象方法
classCatextendsAnimal{
publicvoideat（）{
System.out.println（"猫吃鱼"）;
}
}
classAbstractDemo{
publicstaticvoidmain（String[]args）{
//创建对象
//Animal是抽象的;无法实例化
//Animala=newAnimal（）;
//通过多态的方式
Animala=newCat（）;
a.eat（）;
}
}
2抽象类中成员的特点
/*
抽象类的成员特点：
成员变量：
既可以是变量，也可以是常量。
构造方法：
有。
用于子类访问父类数据的初始化。
成员方法：
既可以是抽象的，也可以是非抽象的。
抽象类的成员方法特性：
A:
抽象方法强制要求子类做的事情。
B:
非抽象方法子类继承的事情，提高代码复用性。
*/
abstractclassAnimal{
publicintnum=10;
publicfinalintnum2=20;
publicAnimal（）{}
publicAnimal（Stringname,intage）{}
publicabstractvoidshow（）;
publicvoidmethod（）{
System.out.println（"method"）;
}
}
classDogextendsAnimal{
publicvoidshow（）{
System.out.println（"showDog"）;
}
}
classAbstractDemo2{
publicstaticvoidmain（String[]args）{
//创建对象
Animala=newDog（）;
a.num=100;
System.out.println（a.num）;
//a.num2=200;
System.out.println（a.num2）;
System.out.println（"--------------"）;
a.show（）;
a.method（）;
}
}
3抽象类方法
/*
一个类如果没有抽象方法，可不可以定义为抽象类?
如果可以，有什么意义?
A:
可以。
B:
不让创建对象。
abstract不能和哪些关键字共存?
private冲突
final冲突
static无意义
*/
abstractclassFu{
//publicabstractvoidshow（）;
//非法的修饰符组合:
abstract和private
//privateabstractvoidshow（）;
//非法的修饰符组合
//finalabstractvoidshow（）;
//非法的修饰符组合
staticabstractvoidshow（）;
publicstaticvoidmethod（）{
System.out.println（"method"）;
}
}
classZiextendsFu{
publicvoidshow（）{}
}
classAbstractDemo3{
publicstaticvoidmain（String[]args）{
Fu.method（）;
}
}
4抽象猫狗案例
/*
猫狗案例
具体事物：
猫，狗
共性：
姓名，年龄，吃饭
分析：
从具体到抽象
猫:
成员变量：
姓名，年龄
构造方法：
无参，带参
成员方法：
吃饭（猫吃鱼）
狗:
成员变量：
姓名，年龄
构造方法：
无参，带参
成员方法：
吃饭（狗吃肉）
因为有共性的内容，所以就提取了一个父类。
动物。
但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
而方法是抽象的类，类就必须定义为抽象类。
抽象动物类：
成员变量：
姓名，年龄
构造方法：
无参，带参
成员方法：
吃饭（）;
实现：
从抽象到具体
动物类:
成员变量：
姓名，年龄
构造方法：
无参，带参
成员方法：
吃饭（）;
狗类：
继承自动物类
重写吃饭（）;
猫类：
继承自动物类
重写吃饭（）;
*/
//定义抽象的动物类
abstractclassAnimal{
//姓名
privateStringname;
//年龄
privateintage;
publicAnimal（）{}
publicAnimal（Stringname,intage）{
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
//定义一个抽象方法
publicabstractvoideat（）;
}
//定义具体的狗类
classDogextendsAnimal{
publicDog（）{}
publicDog（Stringname,intage）{
super（name,age）;
}
publicvoideat（）{
System.out.println（"狗吃肉"）;
}
}
//定义具体的猫类
classCatextendsAnimal{
publicCat（）{}
publicCat（Stringname,intage）{
super（name,age）;
}
publicvoideat（）{
System.out.println（"猫吃鱼"）;
}
}
//测试类
classAbstractTest{
publicstaticvoidmain（String[]args）{
//测试狗类
//具体类用法
//方式1：
Dogd=newDog（）;
d.setName（"旺财"）;
d.setAge（3）;
System.out.println（d.getName（）+"---"+d.getAge（））;
d.eat（）;
//方式2：
Dogd2=newDog（"旺财",3）;
System.out.println（d2.getName（）+"---"+d2.getAge（））;
d2.eat（）;
System.out.println（"---------------------------"）;
Animala=newDog（）;
a.setName（"旺财"）;
a.setAge（3）;
System.out.println（a.getName（）+"---"+a.getAge（））;
a.eat（）;
Animala2=newDog（"旺财",3）;
System.out.println（a2.getName（）+"---"+a2.getAge（））;
a2.eat（）;
//练习：
测试猫类
}
}
5抽象类老师案例
/*
老师案例
具体事物：
基础班老师，就业班老师
共性：
姓名，年龄，讲课。
分析：
基础班老师
姓名，年龄
讲课。
就业班老师
姓名，年龄
讲课。
实现：
老师类
基础班老师
就业班老师
*/
//定义抽象的老师类
abstractclassTeacher{
//姓名
privateStringname;
//年龄
privateintage;
publicTeacher（）{}
publicTeacher（Stringname,intage）{
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
//抽象方法
publicabstractvoidteach（）;
}
//基础班老师类
classBasicTeacherextendsTeacher{
publicBasicTeacher（）{}
publicBasicTeacher（Stringname,intage）{
super（name,age）;
}
publicvoidteach（）{
System.out.println（"基础班老师讲解JavaSE"）;
}
}
//就业班老师类
classWorkTeacherextendsTeacher{
publicWorkTeacher（）{}
publicWorkTeacher（Stringname,intage）{
super（name,age）;
}
publicvoidteach（）{
System.out.println（"就业班老师讲解JavaEE"）;
}
}
classAbstractTest2{
publicstaticvoidmain（String[]args）{
//具体的类测试，自己玩
//测试（多态）
//基础班老师
Teachert=newBasicTeacher（）;
t.setName（"刘意"）;
t.setAge（30）;
System.out.println（t.getName（）+"---"+t.getAge（））;
t.teach（）;
System.out.println（"--------------"）;
t=newBasicTeacher（"刘意",30）;
System.out.println（t.getName（）+"---"+t.getAge（））;
t.teach（）;
System.out.println（"--------------"）;
//就业班老师
t=newWorkTeacher（）;
t.setName（"林青霞"）;
t.setAge（27）;
System.out.println（t.getName（）+"---"+t.getAge（））;
t.teach（）;
System.out.println（"--------------"）;
t=newWorkTeacher（"林青霞",27）;
System.out.println（t.getName（）+"---"+t.getAge（））;
t.teach（）;
}
}
6抽象类学生案例
/*
学生案例
具体事务：
基础班学员，就业班学员
共性：
姓名，年龄，班级，学习，吃饭
分析：
基础班学员
成员变量：
姓名，年龄，班级
成员方法：
学习，吃饭
就业班学员
成员变量：
姓名，年龄，班级
成员方法：
学习，吃饭
得到一个学员类。
成员变量：
姓名，年龄，班级
成员方法：
学习，吃饭
实现：
学员类
基础班学员
就业班学员
*/
//定义抽象学员类
abstractclassStudent{
//姓名
privateStringname;
//年龄
privateintage;
//班级
privateStringgrand;
publicStudent（）{}
publicStudent（Stringname,intage,Stringgrand）{
this.name=name;
this.age=age;
this.grand=grand;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
publicStringgetGrand（）{
returngrand;
}
publicvoidsetGrand（Stringgrand）{
this.grand=grand;
}
//学习
publicabstractvoidstudy（）;
//吃饭
publicvoideat（）{
System.out.println（"学习累了,就该吃饭"）;
}
}
//具体基础班学员类
classBasicStudentextendsStudent{
publicBasicStudent（）{}
publicBasicStudent（Stringname,intage,Stringgrand）{
super（name,age,grand）;
}
publicvoidstudy（）{
System.out.println（"基础班学员学习的是JavaSE"）;
}
}
//具体就业班学员类
classWorkStudentextendsStudent{
publicWorkStudent（）{}
publicWorkStudent（Stringname,intage,Stringgrand）{
super（name,age,grand）;
}
publicvoidstudy（）{
System.out.println（"就业班学员学习的是JavaEE"）;
}
}
classAbstractTest3{
publicstaticvoidmain（String[]args）{
//我仅仅测试基础班学员
//按照多态的方式测试
Students=newBasicStudent（）;
s.setName（"林青霞"）;
s.setAge（27）;
s.setGrand（"1111"）;
System.out.println（s.getName（）+"---"+s.getAge（）+"---"+s.getGrand（））;
s.study（）;
s.eat（）;
System.out.println（"--------------"）;
s=newBasicStudent（"武鑫",48,"1111"）;
System.out.println（s.getName（）+"---"+s.getAge（）+"---"+s.getGrand（））;
s.study（）;
s.eat（）;
//就业班测试留给自己玩
}
}
7抽象类员工案例
/*
假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：
姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。
要求类中提供必要的方法进行属性访问。
分析：
普通员工类
成员变量：
姓名、工号以及工资。
成员方法：
工作
经理类：
成员变量：
姓名、工号以及工资，奖金属性
成员方法：
工作
实现：
员工类：
普通员工类：
经理类：
*/
//定义员工类
abstractclassEmployee{
//姓名、工号以及工资
privateStringname;
privateStringid;
privateintsalary;
publicEmployee（）{}
publicEmployee（Stringname,Stringid,intsalary）{
this.name=name;
this.id=id;
this.salary=salary;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetId（）{
returnid;
}
publicvoidsetId（Stringid）{
this.id=id;
}
publicintgetSalary（）{
returnsalary;
}
publicvoidsetSalary（intsalary）{
this.salary=salary;
}
//工作
publicabstractvoidwork（）;
}
//普通员工类
classProgrammerextendsEmployee{
publicProgrammer（）{}
publicProgrammer（Stringname,Stringid,intsalary）{
super（name,id,salary）;
}
publicvoidwork（）{
System.out.println（"按照需求写代码"）;
}
}
//经理类
classManagerextendsEmployee{
//奖金
privateintmoney;//bonus奖金
publicManager（）{}
publicManager（Stringname,Stringid,intsalary,intmoney）{
super（name,id,salary）;
this.money=money;
}
publicvoidwork（）{
System.out.println（"跟客户谈需求"）;
}
publicintgetMoney（）{
returnmoney;
}
publicvoidsetMoney（intmoney）{
this.money=money;
}
}
classAbstractTest4{
publicstaticvoidmain（String[]args）{
//测试普通员工
Employeeemp=newProgrammer（）;
emp.setName（"林青霞"）;
emp.setId（"czbk001"）;
emp.setSalary（18000）;
System.out.println（emp.getName（）+"---"+emp.getId（）+"---"+emp.getSalary（））;
emp.work（）;
System.out.println（"-------------"）;
emp=newProgrammer（"林青霞","czbk001",18000）;
System.out.println（emp.getName（）+"---"+emp.getId（）+"---"+emp.getSalary（））;
emp.work（）;
S
升级会员 