抽象类的定义与使⽤
抽象类
##1.抽象类的定义与使⽤
**抽象类：**在普通类的基础上扩充了⼀些抽象⽅法（0~n）的类（抽象类是普通类的超集），使⽤abstract关键字定义。抽象类不能直接产⽣实例化对象，因为抽象类是“半成品”，⽆法直接使⽤。不能直接new
**抽象⽅法：**使⽤abstract 关键字定义并且没有⽅法体的⽅法。抽象⽅法所在类⼀定是抽象类。
abstract class Person{
public abstract void print();//抽象⽅法
}
public native void test();//本地⽅法（调⽤C或者其他语⾔同名⽅法）。也没有⽅法体
2.抽象类的使⽤原则
1）所有抽象类必须有⼦类 ：（abstract与final不能同时出现，编译出错）
//抽象类的定义与使⽤
abstract final class Person{//此处报错  abstract与final关键字不能同时出现
static int num=10;
public abstract void print();
}
public class Test16{
public static void main(String[] args){
System.out.println(Person.num);
}
}
2） 如果⼦类不是抽象类 ，⼦类必须覆写抽象类（⽗类）的所有抽象⽅法。（⼦类是抽象类则可以不要求全部覆写）
abstract class Person{
abstract void print();
abstract void fun();
}
class Student extends Person{
static int num=10;
public void print(){}
//public void fun(){}//报错
}
public class Test17{
public static void main(String[] args){
// Person per = new Student();
//Student stu = new Student();
System.out.println(Student.num);
}
}
3）抽象类可以使⽤⼦类向上转型对其实现实例化，抽象类⼀定不能直接实例化对象（⽆论是否有抽象⽅法）
abstract class Person{
public abstract void print();
}
class Student extends Person{
public void print(){
System.out.println("hello i am student");
}
}
public class Test19{
public static void main(String[] args){
//Person per = new Student();
Person per =new Person();//此处报错
per.print();
}
}
//正确写法：
public class Test19{
public static void main(String[] args){
Person per =new Student();//正确写法由⼦类向上转型实现实例化
per.print();
}
}
4)由于抽象类强制要求⼦类覆写⽗类⽅法，所以private 与 abstract 不能同时使⽤。（private 修饰私有属性，被private修饰的属性和⽅法不能被外部使⽤）
abstract class Person{
private abstract void print();//此时报错  private 与 abstract不能同时使⽤
}
class Student extends Person{
public void print(){
System.out.println("hello world");
}
}
public class Test18{
public static void main(String[] args){
Person per =new Student();
}
}
抽象类的相关规定
1).抽象类也存在抽象⽅法，并且⼦类也⼀定按照构造实例化流程。先调⽤抽象类构造⽅法，再调⽤⼦类构造⽅法。
abstract class Person{
private String  name;//属性
public Person(){
System.out.println("⽗类构造⽅法！");
}
public void setName(String name){//普通⽅法
this.name=name;
}
public String getName(){//普通⽅法
return name;
}
public abstract void print();//抽象⽅法
}
class Student extends Person{
private int age;
public Student(){//⼦类构造⽅法
System.out.println("⼦类构造⽅法!");
}
public void setAge(int age){//⼦类普通⽅法
this.age=age;
}
public int getAge(){//⼦类普通⽅法
return age;
}
public void print(){//⼦类覆写的⽗类抽象⽅法
//空实现
}
}
public class Test20{
public static void main(String[] args){
new Student();
}
}
2).特殊代码
abstract class A{
public A(){//3.调⽤⽗类构造⽅法
this.print();//4.调⽤⽗类⽅法，⽅法被⼦类覆写
}
public abstract void print();
}
class B extends A{
private int num=100;
public B(int num){//2.调⽤⼦类构造⽅法
super();//3.隐含调⽤⽗类构造⽅法
this.num=num;//为类中属性初始化
}
public void print(){//5.调⽤覆写后的⽅法。此时⼦类对象的属性没有被初始化（对象初始化操作在构造⽅法中执⾏）        System.out.println(this.num);//6.打印数据为数据类型的默认值
}
}
public class Test21{
public static void main(String[] args){
new B(30);//1.实例化⼦类对象
new B(30).print();//修改代码后
}
}
结果为 0 原因：此时⼦类对象的属性没有被初始化，即没有进⼊⼦类的构造⽅法中。
3).补充：关于对象实例化：对象的实例化操作有以下⼏个核⼼步骤：
·进⾏类加载
进⾏类对象的空间开辟
进⾏类对象中属性初始化（构造⽅法）
4).抽象类中允许不定义任何抽象⽅法，此时该抽象⽅法仍然不能直接创建实例化对象
abstract class Person{
private int num;
public void fun(){
System.out.println("*******");
}
}
class Student extends Person{
public void fun(){
System.out.println("&&&&&&&");
}
}
public class Test22{
public static void main(String[] args){
Person per =new Person();//此处报错
}
}
5). 抽象类⼀定不能使⽤final 关键字声明，因为⽤final声明的类不允许有⼦类，⽽抽象类必须有⼦类；
抽象类⼀定不能使⽤private 关键字声明，因为private 关键字表⽰封装，内部操作外部不可见，⽽抽象⽅法 必须被覆写。
6).抽象类也分内部抽象类和外部抽象类。内部抽象类的抽象⽅法与外部抽象类的抽象⽅法⽆关。**当前直接继承哪个抽象类，就覆写其抽象⽅法。**即：若直接继承外部抽象类，则只需覆写外部抽象类的所有抽象⽅法即可
abstract class A{//外部抽象类
public abstract void fun();
abstract class AInner{//内部抽象类
abstract void fun1();
}
}
class B extends A{//⼦类
public void fun(){//只覆写外部类的抽象⽅法
抽象类的使用
System.out.println("0000");
}
}
public class Test23{
public static void main(String[] args)
}
}
//此时程序不报错
//修改程序
class B extends A{
/
*public void fun(){
System.out.println("0000");
} */
public void fun1(){};//覆写内部抽象类的抽象⽅法程序报错
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。