抽象类

1.抽象类概念

抽象类：包含抽象方法的类，相比于普通类，他多了一个抽象方法。

抽象方法：只声明但是没有实现的方法，用abstract关键字来定义。

未实现的举例：

class A
{
	private String name ;
	public void print()
}

在类中声明的方法，有{}则说明有方法体，则实现；没有{}，则未实现。

2.使用规则

包含一个抽象方法的类必须是抽象类

抽象类和抽象方法都使用abstract关键字声明

抽象方法只需要声明不需要实现

抽象类必须被子类继承，子类（不是抽象类）必须覆写全部的抽象方法

3.定义格式

abstract class A
{
	private String name ;
	public abstrct void print();
}

给出实例化代码

//本例是对抽象类的测试
abstract class A
{
	public static final String flag = "china" ;
	private String name  = "Tyrion";
	public String getName()
	{
		return this.name;
	}
	public abstract void print();
}
//继承并覆写
class B extends A
{
	public void print()
	{
		System.out.println("flag = " + flag + ",姓名：" + getName());
	}
}
public class TestAbstract
{
	public static void main(String[] args)
	{
		B b = new B();
		b.print();
	}
}

4.注意问题

4.1

Final定义类不能有子类，但是抽象类定义之后必须有子类，所以抽象类不能与final共存。

final abstract class A
{
	public static final String flag = "china" ;
	private String name  = "Tyrion";
	public A()
	{
		System.out.println("抽象类的构造方法");
	}
	public String getName()
	{
		return this.name;
	}
	public abstract void print();
}

4.2

抽象类也是类，存在构造方法。

//本例是对抽象类的测试
abstract class A
{
	public static final String flag = "china" ;
	private String name  = "Tyrion";
	public A()
	{
		System.out.println("抽象类的构造方法");
	}
	public String getName()
	{
		return this.name;
	}
	public abstract void print();
}
//继承并覆写
class B extends A
{
	public B()
	{
		super();
		System.out.println("子类的构造方法");
	}
	public void print()
	{
		System.out.println("flag = " + flag + ",姓名：" + getName());
	}
}
public class TestAbstract
{
	public static void main(String[] args)
	{
		B b = new B();
		b.print();
	}
}

2.接口

1.接口的概念

接口是一种特殊类，在接口中，包含全局常量和公共抽象方法。

格式：

Intterface 接口名称{

Public static fianl xxx

Public abstrac xxx

}

//本例是对接口的测试
interface A
{
	public static final String NAME ="Tyrion";
	public abstract void print();
}
public class TestAbstract
{
	public static void main(String[] args)
	{

	}
}

2.接口的实现

由于接口中有抽象方法，所以要通过子类使用implements关键字来实现接口（可以实现多个接口），在子类中要全部覆写抽象方法。

格式：

Class A   implements 接口1,接口2  {}

//本例是对接口的测试
interface A		//定义接口A
{
	public static final String NAME ="Tyrion";
	public abstract void print();
}
interface B		//定义接口B
{
	public abstract void say();
}
class C implements A,B		//子类C实现接口A,B
{
	public void print()
	{
		System.out.println("hello");
	}
	public void say()
	{
		System.out.println("world");
	}
}
public class TestAbstract
{
	public static void main(String[] args)
	{
		C c =new C();	//实例化子类对象
		c.print();
		c.say();
	}
}

一个子类（不是抽象类）既可以继承抽象类，也可以实现接口。

格式

Class 子类 extends 抽象类 implements 接口1....｛｝

//本例是对接口的测试
interface A		//定义接口A
{
	public static final String NAME ="Tyrion";
	public abstract void printA();
}
interface B		//定义接口B
{
	public abstract void printB();
}
abstract class C		//定义抽象类
{
	public abstract void printC();
}
class D extends C implements A,B		//子类D实现接口A,B并且继承抽象类C
{
	public void printA()			//覆写所有的抽象方法
	{
		System.out.println("接口A");
	}
	public void printB()
	{
		System.out.println("接口B");
	}
	public void printC()
	{
		System.out.println("接口C");
	}
}
public class TestAbstract
{
	public static void main(String[] args)
	{
		D d =new D();	//实例化子类对象
		d.printA();
		d.printB();
		d.printC();
	}
}