1.抽象类 使用abstract修饰类.
2.抽象类当中 可以包含普通类所能包含的成员.
3.抽象类和普通类不一样的是,抽象类当中可以包含抽象方法.
4.抽象方法是使用abstract修饰的.这个方法没有具体的实现.
5.不能实例化抽象类 new
6.抽象类存在的最大意义,就是为了被继承.
7.如果一个普通类 继承了一个抽象类 此时必须重写抽象类当中的方法.
8.如果一个抽象类A 继承了一个抽象类B,此时A当中 不需要重写B中的抽象方法,但是如果A再被普通类继承,就需要重写.
9.抽象方法 不能是私有的,static也不可以 也就是说要满足重写的规则.
10.final 也不可以,他和abstract 是矛盾的.
11.抽象类当中 可以有构造方法,方便子类能够直接调用,来初始化 抽象类当中的成员.
1.抽象类 使用abstract修饰类.
abstract class A {//这是一个抽象类,使用abstract修饰
}
2.抽象类当中 可以包含普通类所能包含的成员.
abstract class A {//这是一个抽象类
int a;//普通成员变量
public int add(int val1,int val2){//普通成员方法
return val1 + val2;
}
}
3.抽象类和普通类不一样的是,抽象类当中可以包含抽象方法.
abstract class A {//这是一个抽象类
abstract public void eat();//这是抽象类的抽象方法,因为抽象方法是要被重写的,所以不需要实现细节.
}
4.抽象方法是使用abstract修饰的.这个方法没有具体的实现.
abstract class A {//这是一个抽象类
abstract public void eat();//这是抽象类的抽象方法,因为抽象方法是要被重写的,所以不需要实现细节.
}
5.不能实例化抽象类 new
public class Main {
public static void main(String[] args) {
A a = new A();//这里会报错,因为抽象类是无法被实例化的.
}
}
abstract class A {//这是一个抽象类
int a;//普通成员变量
int b;//普通成员变量
int c;//普通成员变量
abstract public void eat();//这是抽象类的抽象方法,因为抽象方法是要被重写的,所以不需要实现细节.
public int add(int val1,int val2){//普通成员方法
return val1 + val2;
}
}
6.抽象类存在的最大意义,就是为了被继承.
abstract class A {//这是一个抽象类
int a;//普通成员变量
abstract public void eat();//这是抽象类的抽象方法,因为抽象方法是要被重写的,所以不需要实现细节.
}
class B extends A{//这里会报错 因为继承抽象类,要重写其中的抽象方法
}
7.如果一个普通类 继承了一个抽象类 此时必须重写抽象类当中的方法.
abstract class A {//这是一个抽象类
int a;//普通成员变量
abstract public void eat();//这是抽象类的抽象方法,因为抽象方法是要被重写的,所以不需要实现细节.
}
class B extends A{
public void eat(){
System.out.println("我继承并重写了 抽象类 A,以及抽象方法 eat");
}
}
8.如果一个抽象类A 继承了一个抽象类B,此时A当中 不需要重写B中的抽象方法,但是如果A再被普通类继承,就需要重写.
abstract class A {//这是一个抽象类
abstract public void eat();//这是抽象类的抽象方法,因为抽象方法是要被重写的,所以不需要实现细节.
}
abstract class B extends A {//一个抽象类 继承一个抽象类 是不需要重写抽象类中方法的,但如果一个类继承了这个类,就需要重写所有的抽象方法才行
abstract public void jump();
}
class C extends B {//此时这个类继承了B,由于B继承了A,于是C类需要重写A 与 B的所有抽象方法才可以
public void eat() {
}
public void jump() {
}
}
9,10.抽象方法 不能是私有的,static也不可以 也就是说要满足重写的规则.final 也不可以,他和abstract 是矛盾的.
abstract class A {//这是一个抽象类
abstract public static void aat();//不可以
abstract public final void bat();//不可以
abstract private void cat();//不可以
abstract public void dat();//可以的 (0.0)
}
11.抽象类当中 可以有构造方法,方便子类能够直接调用,来初始化 抽象类当中的成员.
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
System.out.println(new B(){
}.a);
}
}
abstract class A {//这是一个抽象类
int a;
int b;
A(){//抽象类的构造方法,方便子类帮助父类进行初始化
a = 10;
b = 20;
}
abstract public void dat();//这是一个抽象方法
}
class B extends A{//子类的构造方法
B(){
super();//父类的构造方法
}
public void dat(){//重写抽象类中的抽象方法
}
}
