2 抽象类的概述及特点
* A：抽象类概述
* 抽象就是看不懂
* B：抽象类的特点
* a:抽象类和抽象方法必须有abstract 关键字修饰
* abstract class 类名{}
* public abstract void eat();
* b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者接口
* c:抽象类不能被实例化，那么抽象类如何实例化呢？
* 按多态的方式，由具体的子类实例化，其实这也是多态的一种，抽象类多态。
* d: 抽象类的子类
* 要么是抽象类
* 要么重写抽象类中的所有抽象方法
* C:案例演示
代码：
public class Demo07_polymorphic {
public static void main(String[] args) {
// Fruit fruit = new Fruit(); 这是错误的，抽象类是不允许实例化的（new对象），必须指向子类进行创建对象
Fruit f = new Apple();
f.juice();
}
}
abstract class Fruit {
// 抽象类中可以没有抽象方法
public void juice() {
System.out.println("榨汁");
}
/**
* 有抽象方法之后，子类必须重写该方法
*/
public abstract void eat(); //抽象方法，没有具体的实现，也就是没有大括号中的内容，只有声明
}
class Apple extends Fruit {
public void juice() {
System.out.println("苹果可以榨苹果汁");
}
@Override
public void eat() {
System.out.println("吃苹果");
}
}
class Orange extends Fruit {
public void juice() {
System.out.println("橙子可以榨橙汁");
}
@Override
public void eat() {
System.out.println("吃橙子");
}
}
2.1 抽象类成员的特点
* A:抽象类的成员特点
* a: 成员变量：既可以是变量，也可以是常量。
* abstract是否可以修饰成员变量？不能修饰成员变量
* b:构造方法：有
* 用于子类访问父类数据的初始化。
* c: 成员方法：既可以是抽象的（子类直接重写父类的抽象方法），也可以是非抽象的非抽象的子类直接继承就可以使用。
* B:案例演示
* 抽象类的成员特点
* C:抽象类的成员方法的特性：
* a:抽象方法强制要求子类做的事情 子类必须重写父类的抽象方法
* b:提高代码的复用性
代码：
public class Demo02_Abstract {
public static void main(String[] args) {
Demo demo = new Test(); // 父类引用指向子类对象
demo.method();
System.out.println(demo.num);
}
}
// 抽象类
abstract class Demo{
/*
* * a: 成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量？
* 不能修饰成员变量
*/
public static final int num = 10; // 常量 加不加final,默认给加上final 建议:自己在写的时候加上final
final int num2 = 20; // final修饰的成员变量只能赋值一次
//* b:构造方法：有
public Demo() {
}
public void print() {
System.out.println("11111111");
}
public abstract void method(); // 抽象方法
}
// Test类继承了Demo类
class Test extends Demo{
//要遵守人家的规则，大家都这样做是不是更有效率，项目中提前开会规定好制度，有规则。
//在继承的时候还可以使用其他体系
// 重写父类Demo的method抽象方法
public void method() {
System.out.println("222222222222");
}
}
2.2 抽象类案例练习
* A:案例演示
* 具体事物：猫狗
* 共性：姓名，年龄，吃饭
* 猫的特性：抓老鼠
* 狗的特性：看家
代码：
package com.jhedu.day09;
import java.util.concurrent.Callable;
public class Demo04_Abstract {
public static void main(String[] args) {
Cat c = new Cat("加菲", 8);
System.out.println(c.getName() + "..." + c.getAge());
c.eat();
c.catchMouse(); // 子类Cat的特有行为
Dog d = new Dog("Odi", 9);
System.out.println(d.getName() + "..." + d.getAge());
d.eat();
d.lookHome(); // 子类Dog的特有行为
}
}
// 定义动物类——抽象类
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 Cat extends Animal {
public Cat() {
super(); // 调用父类构造方法
}
public Cat(String name, int age) {
super(name, age); // 调用父类有参数构造方法
}
@Override
public void eat() {
System.out.println("Cat吃鱼");
}
// 猫可以抓老鼠，猫的特有 行为
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
// Dog继承了Animal类
class Dog extends Animal {
public Dog() {
super();
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("Dog 吃骨头");
}
// Dog的特有行为
public void lookHome() {
System.out.println("Dog可以看家");
}
}