6.Java_抽象类的定义,抽象方法的定义,抽象类的使用原则与相关规定

Java 专栏收录该内容
23 篇文章 0 订阅

一、抽象类

	定义:在普通类的基础上扩充了一些抽象方法 。

1. 抽象方法:只声明而未实现的方法(没有方法体

  • 所有抽象方法使用abstract定义。同时抽象方法所在的类也要用abstract定义,表示抽象类。
  • 举例:定义一个抽象类:

抽象类中没有具体实现,因此抽象类不能直接实例化对象

abstract class Person{
	private String name;//姓名属性
	public String getName(){
		return this.name;
	}
	public void setName(String name){
		this.name = name;
	}
	//{}为方法体,所有抽象方法没有方法体{}
	public abstract void getPersonInfo();//抽象方法
}	

2.抽象类的使用原则

(1)抽象类必须有子类(abstract与final不能同时使用)。
(2)子类覆写抽象类所有的抽象方法(abstract与private不能同时使用)。
(3)抽象类实例化对象,必须通过子类向上转型来实例化对象(抽象类无法直接实例化对象)。
final与abstract不能同时使用
private与abstract不能同时使用

//抽象类的标准操作,也是常用操作。

abstract class Person{
	//姓名属性
	private String name;
	//普通方法
	public String getName(){
		return this.name;
	}
	public void setName(String name){
		this.name=name;
	}
	//抽象方法
	public abstract void getPersonInfo();
}

//子类继承抽象类
class Student extends Person{
	public void getPersonInfo(){
		System.out.println("I am a student");
	}
}	

public class Test{
	public static void main(String[] args){
		//实例化子类,向上转型
		Person per = new Student();	
		//被子类所覆写的方法
		per.getPersonInfo();
	}
}

运行结果:I am a student
abstract class Person{
    private String name ; // 属性
    public String getName(){ // 普通方法
        return this.name;
    }
    public void setName(String name){
        this.name = name ;
    }
    
    public abstract void getPersonInfo() ; //抽象方法

    public static Person getInstance() { //取得A类对象
    	//定义抽象类的子类 (内部类)
        class Student extends Person {  
            public void getPersonInfo() {
                System.out.println("I am a student");
            }
        }
        return new Student();
    }
}

public class Test{
    public static void main(String[] args) {
        Person per = Person.getInstance();
        per.getPersonInfo() ; //被子类所覆写的方法
    }
}

运行结果:I am a student

3.抽象类的相关规定

(1)抽象类也提供构造方法,并且子类也遵循对象实例化流程:先调用父类构造方法,再调用子类构造方法

abstract class Person{
	private String name;
	public String getName(){
		return name;
	}
	
	//父类构造方法
	public Person(){
		System.out.println("1.**************");
	}

	//抽象方法
	public abstract void fun();
}

class Student extends Person{
	//子类构造方法
	public Student(){
		System.out.println("2.##############");
	}

	public void fun(){
		System.out.println("子类继承抽象类");
	}
}
public class Test{
	public static void main(String[] args){
		new Student();//先调用父类构造方法,再调用子类构造方法
	}
}

运行结果:
1.**************
2.##############
//面试题

abstract class Person{
	public Person(){//3.调用父类构造
		this.print();//4.调用被子类覆写的方法
	}
	public abstract void print();//抽象方法
}

class Student extends Person{
	private int num = 100;//此句在对象new成功后才会用到,此句告诉构造方法要将num赋值为100
	public Student(int num){//2.调用子类实例化对象
		// super();//3.隐含这一句,实际要先调用父类构造。此时还未执行“将num赋值为100”的操作,就去调用父类构造了。num默认为int的默认值0。
		//num=100;//此句在构造方法中隐式实现。
		//总的来说,构造方法会隐藏  给变量的赋值操作。 
		
		this.num=num;//7.为类中属性初始化
	}
	public void print(){//5.此时子类对象的属性还没有被初始化
		System.out.println(this.num);//6.输出其对应数据类型的默认值,为0
	}
}

public class Test{
	public static void main(String[] args){
		//先调用父类构造方法,再调用子类构造方法。调用父类构造后,调用打印方法,输出num的值0。调用子类构造,在内存中完成num赋值为30,但并未调用打印方法,因而只有一个值。
		new Student(30);//1.实例化子类对象
	}
}
//父类中num=0,子类中num=30。但由于子类中没有调用打印方法,所以只有一个父类的num值,为0。
运行结果:0

(2)抽象类中可以不定义抽象方法,但仍然无法直接实例化对象。
在这里插入图片描述
(3)abstract与final、private不能一起用。

  • final声明的类不允许有子类,而abstract抽象类必须有子类。
  • 抽象方法必须要被覆写,因此不能用private封装。
    (4)抽象类也分为内部抽象类和外部抽象类。
  • 内部抽象类(了解)可以使用static定义来描述外部抽象类
    在这里插入图片描述
    如果此时在外部抽象类中使用static就会出现语法错误,但是内部抽象类允许使用static
//内部抽象类使用static修饰

abstract class A{//此结果出现几率很低
	public abstract void printA();
	static abstract class B{
		public abstract void printB();
	}
}
class x extends A.B{
	public void printB(){}
}
注意:对象实例化的核心步骤
  ①类加载
  ②类对象的空间开辟
  ③类对象中的属性初始化(构造方法)
方法可以重写,属性不能重写。
  • 5
    点赞
  • 0
    评论
  • 34
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值