全网最全抽象类abstract讲解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1)一个类要被定义为抽象类,必须有关键字 :abstract
位置在类上进行修饰 : abstract class
2)什么抽象方法?
只是给一个方法声明,不做具体体现 (就是一个方法没有方法体{})
public abstract void method(); 抽象方法
如果一个方法被abstract修饰了,那么是抽象方法,不能使用{}
3)有抽象方法的类一定要被abstract修饰,否则编译报错
4)抽象类中一定都是抽象方法吗?
错的,不一定,抽象类中可以有 抽象方法,也可以是非抽象方法;
5)抽象类不能实例化,如何创建对象呢?
可以通过抽象类的子类进行实例化
a)子类是抽象类,无意义(子类都不能实例化)
b)子类是具体类,创建对象使用多态
Animal a = new Cat() ;
6)抽象类的子类,必须重写父类中的抽象方法!
抽象类中是有构造方法的,但是不能直接实例化,需要子类进行数据初始化!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
abstract class Animal{
//抽象的方法
//public abstract void eat(){}
//抽象方法不能有主体
public abstract void eat(); //仅仅是一个声明
public void method(){
System.out.println("method animal...");
}
public Animal(){ //无参
}
public Animal(String name,int age){
}
}
//狗类 ,抽象类
abstract class Dog extends Animal{//dog是抽象的; 无法实例化
}
//具体类
//class Cat extends Animal{ //报错 Cat不是抽象的, 并且未覆盖Animal中的抽象方法eat()
//}
class Cat extends Animal{
//子类继承抽象的父类,一定要将抽象父类中的所有的抽象方法复写
public void eat(){
System.out.println("猫吃鱼...") ;
}
}
//测试类
class AbstractDemo{
public static void main(String[] args){
//创建Animal对象
//Animal a = new Animal() ;//Animal是抽象的; 无法实例化(无法创建对象)
//使用多态进行对象的创建
//Animal a = new Dog() ;
//子类是具体类,使用多态的形式
Animal a = new Cat() ;
a.eat() ;
}
}

1
2
3
4
5
6
7
8
9
10

成员变量
既可以是常量(需要用final进行修饰),也可以是变量
成员方法
既可以定义抽象方法,也可以定义非抽象方法;
构造方法
可以有有参,无参的构造方法,由于类抽象类,所以不能直接实例化,构造方法如何初始化?
通过子类进行数据的初始化
Animal a = new Cat() ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
abstract class Animal{
//成员变量
public int num = 100 ;
public final int num2 = 50 ;
public void show(){
System.out.println(num) ;
System.out.println(num2) ;
}
//public
void method();
//缺少方法主体, 或声明抽象
//只要定义一个抽象方法,那么一定要使用abstract关键字声明,否则报错
public abstract void method() ;
public Animal(){}
public Animal(String name,int age){
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
abstract class Fu{
//abstract可以修饰成员方法
//private abstract void show() ;
// 非法的修饰符组合: abstract和private
//public abstract void show() ;
//abstract static void show() ;//非法的修饰符组合: abstract和static
()
//public final abstract void show() ; //非法的修饰符组合: abstract和final
public abstract void show() ;
}
class Zi extends Fu{
public void show(){
//重写父类的方法的时候,访问权限最好给大,public
System.out.println("show Zi...") ;
}
}
class AbstractDemo3{
public static void main(String[] args){
Fu fu
= new Zi() ;
fu.show() ;
}
}