抽象类的特点：
/* 抽象类的概述： 动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。 我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。 抽象类的特点： A:抽象类和抽象方法必须用abstract关键字修饰 B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类 C:抽象类不能实例化 因为它不是具体的。 抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢? 用于子类访问父类数据的初始化 D:抽象的子类 a:如果不想重写抽象方法，该子类是一个抽象类。 b:重写所有的抽象方法，这个时候子类是一个具体的类。 抽象类的实例化其实是靠具体的子类实现的。是多态的方式。 Animal a = new Cat(); */ //abstract class Animal //抽象类的声明格式 abstract class Animal { //抽象方法 //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体 public abstract void eat(); //抽象类有构造方法，但是不能实例化 public Animal(){} } //要么子类是抽象类 abstract class Dog extends Animal {} //要么子类是具体类，重写抽象方法 class Cat extends Animal { public void eat() { System.out.println("猫吃鱼"); } } class AbstractDemo { public static void main(String[] args) { //创建对象 //Animal a = new Animal();//Animal是抽象的; 无法实例化，可以通过子类实例化 //通过多态的方式，多态主要不是在具体类之间使用，而是在抽象类之间使用 Animal a = new Cat(); a.eat(); } }
抽象类的成员特点：
/* 抽象类的成员特点： 成员变量：既可以是变量，也可以是常量。 构造方法：有。 用于子类访问父类数据的初始化。 成员方法：既可以是抽象的，也可以是非抽象的。 抽象类的成员方法特性： A:抽象方法 强制要求子类做的事情。 B:非抽象方法 子类继承的事情，提高代码复用性。 */ abstract class Animal { public int num = 10; public final int num2 = 20; public Animal() {} public Animal(String name,int age){} public abstract void show(); public void method() { System.out.println("method"); } } class Dog extends Animal { public void show() { System.out.println("show Dog"); } } class AbstractDemo2 { public static void main(String[] args) { //创建对象 Animal a = new Dog(); a.num = 100; System.out.println(a.num);//100 a.num2 = 200; System.out.println(a.num2);//报错，public final int num2 = 20;是常量 System.out.println("--------------"); a.show(); //show Dog a.method();//method } } 抽象类练习猫狗案例：
/* 猫狗案例 具体事物：猫，狗 共性：姓名，年龄，吃饭 分析：从具体到抽象 猫: 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：吃饭(猫吃鱼) 狗: 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：吃饭(狗吃肉) 因为有共性的内容，所以就提取了一个父类。动物。 但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的， 而方法是抽象的类，类就必须定义为抽象类。 抽象动物类： 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：吃饭(); 实现：从抽象到具体 动物类: 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：吃饭(); 狗类： 继承自动物类 重写吃饭(); 猫类： 继承自动物类 重写吃饭(); */ //定义抽象的动物类 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); } public void eat() { System.out.println("狗吃肉"); } } //定义具体的猫类 class Cat extends Animal { public Cat() {} public Cat(String name,int age) { super(name,age); } public void eat() { System.out.println("猫吃鱼"); } } //测试类 class AbstractTest { public static void main(String[] args) { //测试狗类 //具体类用法 //方式1： Dog d = new Dog(); d.setName("旺财"); d.setAge(3); System.out.println(d.getName()+"---"+d.getAge()); d.eat(); //方式2： Dog d2 = new Dog("旺财",3); System.out.println(d2.getName()+"---"+d2.getAge()); d2.eat(); System.out.println("---------------------------"); Animal a = new Dog(); a.setName("旺财"); a.setAge(3); System.out.println(a.getName()+"---"+a.getAge()); a.eat(); Animal a2 = new Dog("旺财",3); System.out.println(a2.getName()+"---"+a2.getAge()); a2.eat(); //练习：测试猫类 } } 抽象类练习老师案例：
/* 老师案例 具体事物：基础班老师，就业班老师 共性：姓名，年龄，讲课。 分析： 基础班老师 姓名，年龄 讲课。 就业班老师 姓名，年龄 讲课。 实现： 老师类 基础班老师 就业班老师 */ //定义抽象的老师类 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 BasicTeacher extends Teacher { public BasicTeacher(){} public BasicTeacher(String name,int age) { super(name,age); } public void teach() { System.out.println("基础班老师讲解JavaSE"); } } //就业班老师类 class WorkTeacher extends Teacher { public WorkTeacher(){} public WorkTeacher(String name,int age) { super(name,age); } public void teach() { System.out.println("就业班老师讲解JavaEE"); } } class AbstractTest2 { public static void main(String[] args) { //具体的类测试，自己玩 //测试(多态) //基础班老师 Teacher t = new BasicTeacher(); t.setName("刘意"); t.setAge(30); System.out.println(t.getName()+"---"+t.getAge()); t.teach(); System.out.println("--------------"); t = new BasicTeacher("刘意",30); System.out.println(t.getName()+"---"+t.getAge()); t.teach(); System.out.println("--------------"); //就业班老师 t = new WorkTeacher(); t.setName("林青霞"); t.setAge(27); System.out.println(t.getName()+"---"+t.getAge()); t.teach(); System.out.println("--------------"); t = new WorkTeacher("林青霞",27); System.out.println(t.getName()+"---"+t.getAge()); t.teach(); } } 抽象类练习学员案例：
/* 学生案例 具体事务：基础班学员，就业班学员 共性：姓名，年龄，班级，学习，吃饭 分析： 基础班学员 成员变量：姓名，年龄，班级 成员方法：学习，吃饭 就业班学员 成员变量：姓名，年龄，班级 成员方法：学习，吃饭 得到一个学员类。 成员变量：姓名，年龄，班级 成员方法：学习，吃饭 实现： 学员类 基础班学员 就业班学员 */ //定义抽象学员类 abstract class Student { //姓名 private String name; //年龄 private int age; //班级 private String grand; public Student() {} public Student(String name,int age,String grand) { this.name = name; this.age = age; this.grand = grand; } 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 getGrand() { return grand; } public void setGrand(String grand) { this.grand = grand; } //学习 public abstract void study(); //吃饭 public void eat() { System.out.println("学习累了,就该吃饭"); } } //具体基础班学员类 class BasicStudent extends Student { public BasicStudent() {} public BasicStudent(String name,int age,String grand) { super(name,age,grand); } public void study() { System.out.println("基础班学员学习的是JavaSE"); } } //具体就业班学员类 class WorkStudent extends Student { public WorkStudent() {} public WorkStudent(String name,int age,String grand) { super(name,age,grand); } public void study() { System.out.println("就业班学员学习的是JavaEE"); } } class AbstractTest3 { public static void main(String[] args) { //我仅仅测试基础班学员 //按照多态的方式测试 Student s = new BasicStudent(); 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 = new BasicStudent("武鑫",48,"1111"); System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand()); s.study(); s.eat(); //就业班测试留给自己玩 } } 抽象类练习员工案例：
/* 假如我们在开发一个系统时需要对员工类进行设计，员工包含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("跟客户谈需求"); } 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("-------------"); //由于子类有特有的内容，所以我们用子类来测试 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(); } } 抽象类中的小问题：
/* 一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义? 可以。 意义:不让创建对象。你要访问它，只能通过它的子类。 abstract不能和哪些关键字共存? private 冲突 final 冲突 static 无意义 */ abstract class Fu { //public abstract void show();为了让子类重写的 //private abstract void show();//报错:非法的修饰符组合: abstract和private，私有不能被继承，子类也就不能重写了， //而抽象类中的抽象方法是要求子类重写的 //报错:非法的修饰符组合 //final abstract void show(); //报错:非法的修饰符组合，访问一个没有方法体的方法没有意义 static abstract void show(); public static void method() { System.out.println("method"); } } class Zi extends Fu { public void show() {} } class AbstractDemo3 { public static void main(String[] args) { Fu.method(); } }
