博客

抽象类

• 当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
• 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！也就是说，在一个类中，将某个功能给出一个声明(抽象方法：没有方法体的方法)，那么该类定义为抽象类
• 举例：
  
  动物—–>本身是抽象的事物
  
  给出吃的功能—–>将eat方法：没有方法体{}
  
  抽象类和抽象方法必须使用abstract修饰

1. 抽象类：
   
   权限修饰符(public)abstract class 类名{};
2. 抽象方法：
   
   权限修饰符(public)abstract 返回值类型 方法名();

//抽象类的定义
public abstract class 类名 {}
//抽象方法的定义
public abstract void eat();

1. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

//抽象动物类
abstract class Animal{
//定义抽象方法
public abstract void eat();
//非抽象方法
public void show(){
System.out.println("这是一个抽象动物类Animal的非抽象方法");
}
}

 class Cat extends Animal{


	//子类必须重写父类的抽象方法!
	The type Cat must implement the inherited abstract method Animal.eat()
	
	@Override
	public  void eat() {
		System.out.println("猫吃鱼...");
	}

	}
	
	public class AbstractDemo {

		public static void main(String[] args) {
			//创建动物类对象: Animal
			//Animal a = new Animal() ;//Cannot instantiate the type Animal:不能对Animal类型实例化
			//抽象类(父类:动物类)它的实例化需要通过具体的子类实现化
			Animal a = new Cat() ; //父类引用指向子类对象 (父类抽象类):抽象类多态!
			a.eat();
		}
}

抽象类不能实例化


抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态


抽象类的子类


要么重写抽象类中的所有抽象方法要么是抽象类


抽象类的注意事项

：

• 如果一个类中,有抽象方法,那么该类一定是抽象类;抽象类中一定是抽象方法吗?,也可以有非抽象方法
• 抽象类如何实例化呢? 抽象类如何创建对象
  
  抽象类不能直接实例化! ,通过具体的子类进行实例化
  
  格式:
  
  父类名 对象名 =new 子类名() ; 抽象类多态
• 抽象类的子类:
  
  类要么具体类,要么抽象类
  
  子类是具体类,直接可以抽象类多态的形式实例化!
  
  子类是抽象类,应该还要提供更最具体的子类,否则都无法实例化(没有意义!)
• 在抽象类中定义抽象方法的时候,那么抽象方法必须带上修饰符:abstract,不能省略!

抽象类的本质：

强制子类必须完成的事情。

###抽象类的成员特点

• 成员变量：
  • 既可以是变量
  • 也可以是常量
• 成员方法：
  • 抽象方法
  • 普通方法
• 构造方法：
  • 空参构造
  • 有参构造

public abstract class Animal {
private int age = 20;
private final String city = "北京";
public Animal() {}
public Animal(int age) {
this.age = age;
}
public void show() {
age = 40;
System.out.println(age);
// city = "上海";
System.out.println(city);
}
public abstract void eat();
}
//猫类
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
//测试类
public class AnimalDemo {
public static void main(String[] args) {
Animal a = new Cat();
a.eat();
a.show();
}
}

abstract class Fu{
	//成员变量
	public int num = 10 ;
	//自定义常量
	public static final int num2 = 20 ;
	
	//抽象方法
	public abstract void show() ;
	
	//非抽象方法
	public void function() {
		System.out.println("function Fu...");
	}
}

//子类
class Zi extends Fu{
	
	public int num = 100 ;
	@Override
	public void show() {
		int num = 30 ;
		System.out.println(num);
		System.out.println("show Zi...");
	}
	
	public void function() {
		System.out.println("function Zi...");
	}
	
}
//测试类
public class AbstractDemo2 {
	public static void main(String[] args) {
		//抽象类多态测试
		Fu f = new Zi() ;
		System.out.println(f.num);
		System.out.println(Fu.num2);
		f.function(); //编译看左,运行看右
		System.out.println("-----------------");
		//针对具体的子类实例化
		/*
		Zi z = new Zi() ; 
		System.out.println(z.num);
		z.function();
		*/
	}
}

abstract关键字不能和哪些关键字共存

• 不能和final一块使用:
  1. final修饰成员方法:方法不能被重写,但是abstract修饰的方法,强制类完成的事情!
  2. 不能和private一块使用: private只能在类中访问!
  3. 被static修饰的方法直接使用类名调用,—->但是抽象方法又需要让子类重写(静态方法算不上方法重写)
     • 方法重写注意事项:
       • 子类继承父类,子类重写父类的方法必须保证访问权限足够大,使用public修饰(要么跟父类的修饰符保持一致)

抽象类的案例

动物类

public 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();
}

猫类

public class Cat extends Animal {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}

狗类

public class Dog extends Animal {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
 }
}

测试类

public class AnimalDemo {
public static void main(String[] args) {
//创建对象，按照多态的方式
Animal a = new Cat();
a.setName("加菲");
a.setAge(5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
System.out.println("");
a = new Cat("加菲",5);
System.out.println(a.getName()+","+a.getAge());
a.eat();
 }
}