java的抽象类与abstract关键字

文章内容选自尚硅谷，jdk8，eclipse环境

abstract关键字的用法

abstract关键字可以用来修饰类和方法。

abstract关键字修饰类

abstract修饰的类表明该类不可实例化，要想调用类中的方法，就让该类被子类继承，通过子类来调用父类的方法。

代码演示

package com.atguigu.java;

public class AbstractTest {
	public static void main(String[] args) {
//		Person p1 = new Person();
	}
}

abstract class Person{
	String name;
	int age;
	
	public Person(){
		
	}
	
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public void eat(){
		System.out.println("人吃饭");
	}
	
	public void walk(){
		System.out.println("人走路");
	}
}

class Student extends Person{
	
}

注释的部分是编译不通过的部分，因为把Person声明为抽象类，则不可进行实例化。

抽象类中也是有构造器的，它的构造器用于子类的调用。也可以用于创建匿名子类。

abstract关键字修饰方法

• abstract关键字修饰的方法叫做抽象方法。抽象方法没有方法体，不能够被调用。
• 因为抽象方法不能被调用，所以要声明抽象方法所属类也为抽象类。抽象类不一定非得有抽象方法，有抽象方法的类一定是抽象类。
• 抽象方法也会被子类所继承，若想实例化子类对象，就要让子类重写父类所有的抽象方法，这儿的父类包含直接父类和间接父类。否则编译器会报错。
• 子类若不重写父类的抽象方法，则必须把子类也声明为抽象类，否则编译器报错。

演示代码如下

abstract class Person{
	String name;
	int age;
	
	public Person(){
		
	}
	
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	//不是抽象方法，只要有大括号，就算有方法体
//	public void eat(){
//
//	}
	//是抽象方法，因为没有方法体
	public abstract void eat();
	
	public void walk(){
		System.out.println("人走路");
	}
}

抽象方法是没有方法体的，表现形式为没有大括号。

抽象方法只在父类中起一个声明的作用，告诉实例化子类必须重写抽象方法才能使用，子类要重写直接父类和间接父类的所有抽象方法。

public class AbstractTest {
	public static void main(String[] args) {
//		Person p1 = new Person();
	}
}

abstract class creature{
	public abstract void breath();
}

abstract class Person extends creature {
	String name;
	int age;
	
	public Person(){
		
	}
	
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	//不是抽象方法，只要有大括号，就算有方法体
//	public void eat(){
//
//	}
	//是抽象方法，因为没有方法体
	public abstract void eat();
	
	public void walk(){
		System.out.println("人走路");
	}
}

class Student extends Person{
	public Student(String name,int age){
		super(name,age);
	}
	
	public void eat(){
		System.out.println("学生吃饭");
	}

	@Override
	public void breath() {
		System.out.println("学生呼吸");
	}
}

abstract在使用上的注意点

abstract关键字与其他几个关键字的使用有冲突。表现为

• abstract不能用来修饰私有方法，因为私有方法不能被重写。
• abstract不能用来修饰静态方法，子类和父类中若存在同名同参数的方法，如果方法都是非static的，则构成重写，如果都声明为static的，他们不是重写，这是因为静态方法不能被覆盖。如果只有一个是static，编译器报错。
• abstract不能用来修饰final的方法和带final的类。因为final类不能被继承，final方法不能被重写。

abstract练习

图片选自尚硅谷PPT

首先得编写一个Employee得父类，声明为抽象类。

package com.atguigu.exer1;

public abstract class Employee {
	private int id;
	private String name;
	private double salary;
	public Employee() {
		super();
	}
	public Employee(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	public abstract void work();
}

创建构造器时直接alt+shift+s来创建。

再创建一个Manager类，创建子类的时候，在eclipse的弹框中选择继承的父类Employee，可以直接得到重写的work方法。

package com.atguigu.exer1;

public class Manager extends Employee {
	private double bonus;
	
	public Manager(double bonus) {
		super();
		this.bonus = bonus;
	}

	public Manager(int id, String name, double salary, double bonus) {
		super(id, name, salary);
		this.bonus = bonus;
	}

	@Override
	public void work() {
		System.out.println("管理");

	}

}

创建一个CommonEmployee类

package com.atguigu.exer1;

public class CommonEmployee extends Employee {
	
	@Override
	public void work() {
		System.out.println("工作");

	}

	public CommonEmployee(int id, String name, double salary) {
		super(id, name, salary);
		
	}

	public CommonEmployee() {
		super();
		// TODO Auto-generated constructor stub
	}

}

再测试

package com.atguigu.exer1;

public class EmployeeTest {
	public static void main(String[] args) {
		Employee manager = new Manager(1001,"库克",100,1000);
		manager.work();
		CommonEmployee commonemployee = new CommonEmployee();
		commonemployee.work();
	}
}

结果为

管理
工作

此为一个抽象类的简单运用。

创建抽象类的匿名子类对象

匿名对象的使用

首先看匿名对象的使用，在之前AbstractTest的包内建立一个PersonTest类

package com.atguigu.java;

public class PersonTest {
	public static void main(String[] args) {
		
		method(new Student());

	}
	
	public static void method(Student s){
		
	}
}

以上表现为一个匿名对象的使用。但是类并非匿名的。

非匿名类的非匿名的对象

此为正常写法。

package com.atguigu.java;

public class PersonTest {
	public static void main(String[] args) {
		
		method(new Student());
		Worker worker = new Worker();
		method1(worker);//非匿名的非匿名的对象

	}
	
	public static void method(Student s){
		
	}
	
	public static void method1(Person p){
		p.eat();
		p.breath();
	}
}

class Worker extends Person{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void breath() {
		// TODO Auto-generated method stub
		
	}
	
}

如果写成

		method1(new Worker());//非匿名类的匿名对象

即为非匿名类的匿名对象，对象名不知道，但是对象所属的类知道。

匿名子类

在main方法中创建一个匿名类

	public static void main(String[] args) {
		
		method(new Student());
		Worker worker = new Worker();
		method1(worker);//非匿名类的非匿名的对象
		method1(new Worker());//非匿名类的匿名对象
		//匿名类的非匿名对象
		Person p1 = new Person(){

			@Override
			public void eat() {
				System.out.println("eat");
				
			}

			@Override
			public void breath() {
				System.out.println("breath");
				
			}
			
		};

	}

这儿创建了一个匿名类的对象，对象为p1，但类名未知，故称之为匿名类。Person p1 = new Person(){重写的方法}； 这儿大括号内部重写父类的抽象方法，且重写方法的内容是任意的，故为一个新的子类，又没有类名，成为匿名类。这儿也可以看作是一个多态的使用。
在main方法中允许

		method1(p1);

结果为

eat
breath

匿名子类的匿名对象

还可以用匿名类的匿名对象

		method1(new Person(){

			@Override
			public void eat() {
				System.out.println("eat eat");
				
			}

			@Override
			public void breath() {
				System.out.println("breath breath");
				
			}
			
		});

结果为

eat eat
breath breath

注意区分与之前 匿名类的非匿名对象的分号 有一个分号的差别。