标签：java之抽象类
1.抽象类概述
package com;
class Animal{
public void eat(){
System.out.println("动物吃东西");
}
public void sleep(){
System.out.println("动物睡觉");
}
}
class Dog extends Animal{
@Override
public void eat(){
System.out.println("猫吃东西");
}
@Override
public void sleep(){
System.out.println("猫睡觉");
}
}
class Cat extends Animal{
@Override
public void eat(){
System.out.println("狗吃东西");
}
@Override
public void sleep(){
System.out.println("狗睡觉");
}
}
public class AnimalTest {
public static void main(String[] args) {
Animal a = new Dog();
a.eat();
}
}从上面的代码，我们开始思索。动物不是一个具体的事物，而是一个抽象的事物。只有真正的猫、狗才是具体的动物。同理，我们可以推想，不同的动物吃的东西也应该是不一样的。所以，我们不应该在动物类中给出具体的实现细节，而是应该给出一个声明即可。在Java中，一个没有方法体的方法应该被定义为抽象方法，而类中如果有抽象方法，那么该类被称为抽象类。
2.抽象类特点
抽象类和抽象方法必须用abstract关键字修饰。
格式：
abstract class 类名{}
public abstract void eat();
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类。
抽象类不能被实例化。因为它不是具体的。抽象类有构造方法，但是不能实例化？那么构造方法的作用是什么？用于子类访问父类数据的初始化。
抽象类的子类，要么是抽象类，要么实现抽象类中的所有抽象方法。
package com;
abstract class Animal{
public abstract void eat();
public abstract void sleep();
}
class Dog extends Animal{
@Override
public void eat(){
System.out.println("猫吃东西");
}
@Override
public void sleep(){
System.out.println("猫睡觉");
}
}
class Cat extends Animal{
@Override
public void eat(){
System.out.println("狗吃东西");
}
@Override
public void sleep(){
System.out.println("狗睡觉");
}
}
public class AnimalTest {
public static void main(String[] args) {
Animal a = new Dog();//多态
a.eat();
}
}3.抽象类成员特点
成员变量：既可以是变量，也可以是常量。
构造方法：有，用于子类访问父类数据的初始化。
成员方法：既可以是普通方法，也可以是抽象方法。
抽象类的成员方法特性：
抽象方法：强制要求子类做事情。
普通方法：让子类去继承，提高代码的复用性。
4.抽象类案例
package com;
/**
* 具体事务：猫 狗
* 共性：姓名 年龄 吃饭
*
* 分析：从具体到抽象
* 猫：
* 成员变量：姓名 年龄
* 成员方法：吃饭(猫吃鱼)
* 狗:
* 成员变量：姓名 年龄
* 成员方法：吃饭(狗吃肉)
*
* 因为有共性的内容，所以就提取了父类--动物。
* 但是由于吃饭的内容不一样，所以吃饭的方法是抽象的。
* 而方法是抽象的，所以动物类必须为抽象类。
*
* 抽象类：
* 成员变量： 姓名 年龄
* 成员方法： 吃饭()
*
* 实现：从抽象到具体
* 动物类：
* 成员变量： 姓名 年龄
* 成员方法： 吃饭()
* 狗类：
* 继承自动物的类，重写吃饭()
* 猫类：
* 继承自动物的类，重写吃饭()
*/
//抽象类---动物类
abstract class Animal{
private String name;//姓名
private int age;//年龄
//无参构造方法
public Animal(){}
//有参数构造方法
public Animal(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();
}
//具体类--狗类
class Dog extends Animal{
//无参构造方法
public Dog(){}
//有参数构造方法
public Dog(String name,int age){
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
//具体类--猫类
class Cat extends Animal{
//无参构造方法
public Cat(){}
//有参构造方法
public Cat(String name,int age){
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
public class AbstractTest {
public static void main(String[] args) {
Animal a = new Dog("旺财",2);
System.out.println("狗的姓名:"+a.getName()+",年龄:"+a.getAge());
a.eat();
a = new Cat("进宝",3);
a.eat();
System.out.println("猫的姓名:"+a.getName()+",年龄:"+a.getAge());
}
}package com;
/**
* 具体事物：语文老师 数学老师
* 共性：姓名 年龄 讲课
*
* 分析：
* 语文老师
* 姓名 年龄
* 讲课
* 数学老师
* 姓名 年龄
* 讲课
* 实现：
* 老师类
* 语文老师
* 数学老师
*/
//抽象类--老师类
abstract class Teacher{
private String name;//姓名
private int age;//年龄
//无参构造方法
public Teacher(){}
//有参数构造方法
public Teacher(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 teach();
}
//语文老师类
class ChineseTeacher extends Teacher{
//无参构造方法
public ChineseTeacher(){}
//有参构造方法
public ChineseTeacher(String name,int age){
super(name,age);
}
@Override
public void teach() {
System.out.println("讲语文");
}
}
//数学老师类
class MathTeacher extends Teacher{
//无参构造方法
public MathTeacher() {}
//有参构造方法
public MathTeacher(String name,int age){
super(name, age);
}
@Override
public void teach() {
System.out.println("讲数学");
}
}
//测试类
public class AbstractTest1 {
public static void main(String[] args) {
Teacher t = new ChineseTeacher("语文老师哈哈", 40);
System.out.println("语文老师姓名:"+t.getName()+",年龄："+t.getAge());
t.teach();
t = new MathTeacher("数学老师呵呵", 22);
System.out.println("数学老师姓名:"+t.getName()+",年龄："+t.getAge());
t.teach();
}
}package com;
/**
* 学生案例
* 具体事物：文科班学员 理科班学员
* 共性：姓名 年龄 班级 学习 吃饭
* 分析：
* 文科班学员
* 成员变量：姓名 年龄 班级
* 成员方法：学习 吃饭
* 理科班学员
* 成员变量：姓名 年龄 班级
* 成员方法：学习 吃饭
* 得到一个学员类：
* 成员变量：姓名 年龄 班级
* 成员方法：学习 吃饭
* 实现：
* 学员类：
* 文科班学员
* 理科班学员
*
*/
//定义抽象类 学员类
abstract class Employee{
private String name;//姓名
private int age;//年龄
private String classMate;//班级
//无参构造方法
public Employee(){}
//有参构造方法
public Employee(String name,int age,String classMate){
this.name = name;
this.age = age;
this.classMate = classMate;
}
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 getClassMate() {
return classMate;
}
public void setClassMate(String classMate) {
this.classMate = classMate;
}
/**
* 吃饭
*/
public void eat(){
System.out.println("吃饭");
}
/**
* 学习
*/
public abstract void study();
}
//文科学员
class LiberalEmployee extends Employee{
//无参构造方法
public LiberalEmployee(){}
//有参构造方法
public LiberalEmployee(String name,int age,String classMate){
super(name, age, classMate);
}
@Override
public void study() {
System.out.println("学习文科");
}
}
//理科学员
class ScienceEmployee extends Employee{
//无参构造方法
public ScienceEmployee(){}
//有参构造方法
public ScienceEmployee(String name,int age,String classMate){
super(name, age, classMate);
}
@Override
public void study() {
System.out.println("学习理科");
}
}
//测试类
public class AbstractTest2 {
public static void main(String[] args) {
Employee e = new LiberalEmployee("文科学员哈哈",20,"文科班01班");
System.out.println("文科班学员姓名："+e.getName()+",年龄："+e.getAge()+",班级："+e.getClassMate());
e.eat();
e.study();
e = new ScienceEmployee("理科学员呵呵", 18, "理科班01班");
System.out.println("理科班学员姓名："+e.getName()+",年龄："+e.getAge()+",班级："+e.getClassMate());
e.eat();
e.study();
}
}package cn;
/**
* 假如我们在开发一个系统时需要对员工类进行设计。
* 员工包含3个属性：姓名、工号以及工资。
* 经理也是员工，除了含有员工的属性外，还有一个奖金的属性。
* 请使用继承的思想设计出员工类和经理类。
* 要求类中提供必要的方法进行属性访问。
*/
//员工类
abstract class Employee{
private String name;//姓名
private String empno;//编号
private double salary;//薪水
public Employee(){}
public Employee(String name,String empno,double salary){
this.empno = empno;
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmpno() {
return empno;
}
public void setEmpno(String empno) {
this.empno = empno;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
/**
* 工作
*/
public abstract void work();
}
//程序员
class Programmer extends Employee{
//无参构造方法
public Programmer(){}
//有参构造方法
public Programmer(String name,String empno,double salary){
super(name, empno, salary);
}
@Override
public void work() {
System.out.println("按照需求写代码");
}
}
//经理
class Manager extends Employee{
private double bonus;//奖金
//无参构造方法
public Manager(){}
//有参构造方法
public Manager(String name,String empno,double salary,double bonus){
super(name, empno, salary);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("和客户谈需求");
}
}
//测试类
public class AbstractTest {
public static void main(String[] args) {
Employee e = new Programmer("程序员哈哈", "001", 5000);
System.out.println("姓名："+e.getName()+"编号："+e.getEmpno()+"薪水："+e.getSalary());
e.work();
e = new Manager("经理呵呵", "01", 10000, 5000);
System.out.println("姓名："+e.getName()+"编号："+e.getEmpno()+"薪水："+e.getSalary()+"奖金："+((Manager)e).getSalary());
e.work();
}
}5.抽象类小问题
一个类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义。
可以，不让创建对象。
abstract关键字和private关键字、final关键字冲突和static关键字无意义。
本文出自 “11831428” 博客，请务必保留此出处http://11841428.blog.51cto.com/11831428/1858993
标签：java之抽象类
原文地址：http://11841428.blog.51cto.com/11831428/1858993
