抽象类
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();
}
}
在java中接口不能继承抽象类,但是一个接口可以同时继承多个接口
格式:
Interface 子接口 extends 接口1....{}
//本例是对接口的测试
interface A //定义接口A
{
public static final String NAME ="Tyrion";
public abstract void printA();
}
interface B //定义接口B
{
public abstract void printB();
}
interface C extends A,B //子接口C继承接口A,B
{
public abstract void printC();
}
class D implements C //子类D实现接口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();
}
}
祝大家健健康康,快快乐乐。