Java面向对象高级--抽象类的基本概念------abstract

抽象类的概念:

包含一个抽象方法的类就称为抽象类。

抽象方法:只声明但未实现的方法称为抽象方法,使用abstract关键字声明。

抽象类的定义及使用规则:

abstract class A{	// 是定义了一个抽象类
	public static final String FLAG = "CHINA" ;	// 全局常量
	private String name = "XIAOWU" ;	// 定义一个普通的属性
	public void setName(String name){
		this.name = name ;
	}
	public String getName(){
		return this.name ;
	}
	public abstract void print() ;		// 定义抽象方法
};

抽象类的子类覆写抽象类中的抽象方法。

abstract class A{	// 是定义了一个抽象类
	public static final String FLAG = "CHINA" ;	// 全局常量
	private String name = "XIAOWU" ;	// 定义一个普通的属性
	public void setName(String name){
		this.name = name ;
	}
	public String getName(){
		return this.name ;
	}
	public abstract void print() ;		// 定义抽象方法
};
class B extends A{	// 继承抽象类,因为B是普通类,所以必须覆写全部抽象方法
	public void print(){
		System.out.println("FLAG = " + FLAG) ;
		System.out.println("姓名 = " + super.getName()) ;
	}
};
public class AbstractDemo02{
	public static void main(String args[]){
		B b = new B() ;
		b.print() ;
	}
};

抽象类的思考:

abstract class A{	// 是定义了一个抽象类
	public A(){
		System.out.println("A、抽象类中的构造方法。") ;
	}
};
class B extends A{	// 继承抽象类,因为B是普通类,所以必须覆写全部抽象方法
	public B(){
		super() ;
		System.out.println("B、子类中的构造方法。") ;
	}
};
public class AbstractDemo03{
	public static void main(String args[]){
		B b = new B() ;
	}
};

abstract class Person{
	private String name ;		// 定义name属性
	private int age ;			// 定义age属性
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
	public abstract String getInfo() ;	// 抽象方法
};
class Student extends Person{
	private String school ;
	public Student(String name,int age,String school){
		super(name,age) ;	// 指定要调用抽象类中有两个参数的构造方法
		this.school = school ;
	}
	public void setSchool(String school){
		this.school = school ;
	}
	public String getSchool(){
		return this.school ;
	}
	public String getInfo(){
		return	"姓名:" + super.getName()  +
				";年龄:" + super.getAge() +
				";学校:" + this.getSchool() ;
	}
};
public class AbstractDemo04{
	public static void main(String args[]){
		Student stu = new Student("张三",30,"清华大学") ;
		System.out.println(stu.getInfo()) ;
	}
};
时间: 2024-11-03 22:08:11

Java面向对象高级--抽象类的基本概念------abstract的相关文章

Java面向对象高级--抽象类与接口的应用

1.为抽象类和接口实例化 抽象类和接口不能直接实例化,因为其内部包含了各个抽象方法,抽象方法本身都是未实现的方法,所以无法调用.通过对象多态性,子类发生了向上转型之后,所调用的全部方法都是被覆写过了的方法. 为抽象类实例化: abstract class A{ // 定义抽象类A public abstract void print() ; // 定义抽象方法print() }; class B extends A { // 定义子类,继承抽象类 public void print(){ //

Java面向对象高级--Object类

在Java中一切的类都是以继承的关系存在的, class Person{} 如果一个类在定义时,没有明确指明继承那个类,则默认继承Object类. class Person extends Object{} class Demo{ // 定义Demo类,实际上就是继承了Object类 }; public class ObjectDemo01{ public static void main(String args[]){ Demo d = new Demo() ; // 实例化Demo对象 Sy

Java面向对象高级--instanceof关键字

可以使用instanceof关键字判断一个对象到底是那个类的实例. class A{ // 定义类A public void fun1(){ // 定义fun1()方法 System.out.println("A --> public void fun1(){}") ; } public void fun2(){ this.fun1() ; // 调用fun1()方法 } }; class B extends A{ public void fun1(){ // 此方法被子类覆写了

Java面向对象高级--继承的基本实现--extends

1.继承的基本概念 继承:子类继承父类,可以扩展已有类的功能. extends关键字:称为扩展,子类扩展一个类,子类有时候也称为派生类. class Person{ // 定义Person类 private String name ; // 定义name属性 private int age ; // 定义age属性 public void setName(String name){ this.name = name; } public void setAge(int age){ this.age

Java面向对象高级--继承的应用----整形数组类、排序类、反转类

分析: class Array{ // 表示数组 private int temp[] ; // 整型数组 private int foot ; // 定义添加位置 public Array(int len){ if(len>0){ this.temp = new int[len] ; }else{ this.temp = new int[1] ; // 最少维持空间是1个 } } public boolean add(int i){ // 增加元素 if(this.foot<this.tem

Java面向对象高级--实例分析—宠物商店

1.实例要求 实现一个宠物商店,在宠物商店中可以由多种宠物,(由用户决定数量).试表示出此种关系,并要求可以根据宠物的关键字查找到相应的宠物信息.所需要的宠物信息自行设计. 2.实例中主要使用到的知识点:接口.对象数组. 3.分析 interface Pet{ // 定义宠物接口 public String getName() ; public String getColor() ; public int getAge() ; } class Cat implements Pet{ // 猫是宠

Java面向对象高级--对象的多态性

向上转型:通过子类进行父类对象实例化操作.如果调用的方法被子类覆写过,则肯定调用被覆写过的方法.注意:转型之后,因为操作的是父类对象,所以无法找到子类中定义的新方法. class A{ // 定义类A public void fun1(){ // 定义fun1()方法 System.out.println("A --> public void fun1(){}") ; } public void fun2(){ this.fun1() ; // 调用fun1()方法 } }; c

Java面向对象高级--final关键字

class A{ private final String INFO = "INFO" ; // 声明常量 public final void print(){ // 使用final声明的方法不能被覆写 INFO = "HELLO" ; } }; 常量必须在声明时为其明确指定内容. final声明的变量全部用大写字母形式,这也是命名规范. 即:常量全部必须大写. 全局常量: 使用static final关键字联合声明的变量称为全局常量: public static

Java面向对象高级--继承的进一步研究

1.子类对象的实例化过程 class Person{ // 定义Person类 private String name ; // 定义name属性 private int age ; // 定义age属性 public Person(){ System.out.println("父类Person中的构造.") ; } public void setName(String name){ this.name = name; } public void setAge(int age){ th