首页 > 代码库 > Java抽象类、接口和内部类

Java抽象类、接口和内部类

1.抽象方法、抽象类

1)抽象方法:

  • 由abstract修饰
  • 只有方法的定义,没有方法的具体实现(连{}都没有)

  由abstract修饰的方法为抽象方法,抽象方法只有方法的定义,没有方法体实现,用一个分号结尾。即:方法五要素中,抽象方法缺少了一个要素(方法体),也可以将抽象方法理解为不完整的方法。

 

2)抽象类:

  • 由abstract修饰
  • 包含抽象方法的类必须是抽象类,不包含抽象方法的类也可以声明抽象类(意义不大)
  • 抽象类不能被实例化
  • 抽象类是需要被继承的
      • 子类需要重写抽象类的所有抽象方法---常用
      • 子类也可以声明为抽象类---不常用
  • 抽象类的意义:
      • 封装子类所共有的属性和行为---代码复用
      • 为所有子类提供一种统一的类型---向上造型
      • 可以包含抽象方法,为所有子类提供了统一的入口,子类的实现不同,但入口是一致的

  由abstract修饰的类为抽象类,抽象类是不能实例化对象的,而一个类不能实例化是没有意义的,所以需要定义类来继承抽象类,它的子类必须重写所有的抽象方法,除非该类也声明为抽象类。

abstract class Foo{
	private double c;
	public Foo(double c){  //没什么意义,需要被子类重写
		this.c = c;
	}
	public abstract double area();  //抽象方法,没有方法体,大括号也不存在
}
class Sub extends Foo{
	public Sub(double c) {  //需要重写构造方法
		super(c);
	}
	public double area(){
		return 0.0;
	}
}
abstract class Sub2 extends Foo{  //抽象方法继承抽象方法
	public Sub2(double c) {  //需要重写构造方法,不需要重写抽象方法
		super(c);
	}
}

  

3)抽象类不可以被实例化

Foo f = new Foo();  //编译错误,抽象类不能被实例化

  即使一个类中没有抽象方法,也可以将其定义为抽象类,同样,该类不可以实例化。

  注意:abstract和final关键字不能同时修饰一个类,因为final使得类不可继承,而abstract修饰的类如果不可以继承将没有任何意义。

 

4)继承抽象类

  一个类继承抽象类后,必须实现其抽象方法,不同的子类可以有不同的实现。

abstract class Foo{
	private double c;
	public Foo(double c){  //没什么意义,需要被子类重写
		this.c = c;
	}
	public abstract String sayHi();
}
class Sub extends Foo{
	public Sub(double c) {  //需要重写构造方法
		super(c);
	}
	public String sayHi(){
		return "Hello";
	}
}

  

4)抽象类的意义

  • 为其子类提供一个公共的类型(父类引用指向子类对象,即向上造型)
  • 封装子类中的重复内容(成员变量和方法)
  • 定义有抽象方法,子类虽然有不同的实现,但该方法的定义是一致的(子类需要实现此抽象方法)

案例1:抽象类演示

public class AbstractDemo {
	public static void main(String[] args){
//		Shape s = new Shape(); //编译错误,抽象类不能被实例化
		Shape[] shape = new Shape[4];  //创建Shape数组对象
		shape[0] = new Circle(1);  //向上造型
		shape[1] = new Circle(2);
		shape[2] = new Square(1);
		shape[3] = new Square(2);
		maxArea(shape);  //调用求最大面积方法
	}

	private static void maxArea(Shape[] shape) {
		double max = shape[0].area();
		int maxIndex = 0; //最大面积下标
		for(int i=0;i<shape.length;i++){
			double area = shape[i].area();
			if(area>max){
				max = area;
				maxIndex=i;
			}
		}
		System.out.println("最大面积为:"+max+"所在下标为:"+maxIndex);
	}
}
abstract class Shape{ //抽象类---不完整的类
	protected double c; //周长
	public abstract double area(); //抽象方法---不完整
}
class Circle extends Shape{
	public Circle(double c){
		this.c = c;
	}
	public double area(){  //重写抽象方法---变不完整为完整
		return 0.0796*c*c;
	}
}
class Square extends Shape{
	public Square(double c){
		this.c = c;
	}
	public double area(){
		return 0.0625*c*c;
	}
}

  

 

2. 接口

  • 是一个标准、规范,遵循了这个标准就能干某件事
  • 是一种数据类型(引用类型)
  • 由interface定义,只能包含常量和抽象方法,方法默认由public abstract修饰
  • 接口不能被实例化
  • 接口是需要被实现的,通过implements关键字实现,实现类:必须重写接口中的所有抽象方法
  • 一个类可以实现多个接口,逗号分隔,若又继承又实现,必须先继承后实现
  • 接口可以继承一个或多个接口,逗号分隔(extends)

1)定义接口

  接口可以看成是特殊的抽象类。即:只包含抽象方法和常量的抽象类。通过interface关键字来定义接口。

interface Demo{
	public static int x = 100;
	public int y = 50;
	double area();   //默认会加上public abstract修饰
	public abstract void test();
}

  

2)实现接口

  与继承不同,一个类可以实现多个接口,实现的接口直接用逗号分隔,该类需要实现这些接口中定义的所有方法。通过implements关键字实现接口。接口可以作为一种类型声明变量,一个接口类型的变量可以引用实现了该接口的类的对象,通过该变量可以调用该接口中定义的方法(具体的实现类提供了方法的实现)。一个接口类型变量,引用了子类的对象,调用时,调用的是子类对象的具体的实现。

public class Test {
	public static void main(String[] args){
		Demo d = new Aoo();   //一个接口类型变量,引用了子类的对象,调用时,调用的是子类对象的具体的实现
		d.test();   //This is Aoo
	}
}

interface Demo{
	public static int x = 100;
	public int y = 50;
	double area();   //默认会加上public abstract修饰
	public abstract void test();
}
class Aoo implements Demo{
	public double area(){
		return 0.0;
	}
	public void test(){
		System.out.println("This is Aoo");
	}
}

  

3)接口的继承

  接口间可以存在继承关系,一个接口可以通过extends关键字继承另外一个接口,子接口继承了父接口中定义的所有方法。

interface Foo{
	public void funFoo();
}
interface Goo{
	public void funGoo();
}
interface Hoo extends Foo,Goo{  //接口可以继承一个或多个接口,逗号分隔
	public void funHoo();
}
interface Ioo{
	void funIoo();
}

class Joo implements Hoo,Ioo{  //一个类可以继承多个接口
	public void funFoo(){}  //重写父类的父类的抽象方法
	public void funGoo(){}  //重写父类的父类的抽象方法
	public void funHoo(){}  //重写父类的抽象方法
	public void funIoo(){}   //重写父类的抽象方法
}

  

4)接口和抽象类的区别

  • 一个类只能继承一个抽象类,但可以实现多个接口
  • 抽象类中可以包含抽象方法和非抽象方法,而接口中的所有方法均为抽象的
  • 子类继承抽象类必须实现抽象类中所有抽象方法,否则子类也必须是抽象类。而子类实现接口则必须实现接口中所有的抽象方法。

 

案例2:接口的演示

public class InterfaceDemo {
	public static void main(String[] args){
//		Inter6 o1= new Inter6();   //编译错误,接口不能被实例化
		Inter6 o2 = new Moo();  //向上造型
		Inter5 o3 = new Moo();
	}
}
//演示接口语法
interface Inter1{
	public static final int NUM = 5;
	public abstract void show();
	double PI = 3.14; //默认public static final修饰
	void say();  //默认public abstract修饰
//	int count; //编译错误,常量必须声明同时初始化
//	void test(){}  //编译错误,抽象方法没有方法体
}

//演示接口实现
interface Inter2{
	void show();
	void say();
}
class Joo implements Inter2{
	public void show(){}
	public void say(){}
}

//演示接口的多实现、继承
interface Inter3{
	void show();
}
interface Inter4{
	void say();
}
abstract class Koo{
	abstract void test();
}
class Loo extends Koo implements Inter3,Inter4{
	public void show(){}
	public void say(){}
	void test(){}
}

//演示接口继承接口
interface Inter5{
	void show();
}
interface Inter6 extends Inter5{
	void say();
}
class Moo implements Inter6{
	public void show(){}
	public void say(){}
}

  

 

 

 

 

 

 

 

 

Java抽象类、接口和内部类