java接口和内部类知识点总结

昨天总结到接口了，没总结完，今天从接口开始。再加个内部类

接口

接口允许多重继承

一个类在继承另一个类的同时,还可以实现多个接口

interface IA1{
public void p1();
}
interface IA2{
public void p2();
}
interface IC extends IA1,IA2{
public void p3();
//继承父接口的同时也允许自定义方法
}//可以继承多个父接口,此时IC中实际有3个抽象方法

类是单根继承,不允许继承多个父类

允许一个类实现多个接口,但是每个接口的抽象方法都必须提供实现,否则是抽象类。提供的实现也可以是继承

public class A1{
public void p1(){}
}
public class A2 extends A1 implements IA1,IA2{
public void p2(){}
}
public abstract class A3 extends A1 implements IA1,IA2{}
//这里是错的，因为p2方法没有实现

接口的出现避免了单继承的局限性,这样定义C接口就拥有A+B的所有定义,可以使用A和B接口以及父类D声明变量类型,直接new T。但是约束时,用谁声明变量编译器系统识别就是谁这种类型,也就意味只能调用识别类型中的方法,不能调用其他方法

interface A{
public void p1();
}
interface B{
public void p2();
}
interface C extents A,B{}
class D{
public void abc(){}
}
class T extends D implements C{
public void p1(){}
public void p2(){}
}
D d=new T();这里只能直接调用abc方法,如果使用其他方法则需要进行类型转换
A a=new T();这里只能直接调用A接口中声明的方法p1
B b=new T();这里只能直接调用B接口中声明的方法p2
C c=new T();

声明接口的语法

访问修饰符 interface 接口名{}一般建议接口名称使用形容词

• 如果定义public接口,则规则和定义public类一致,要求接口名称和文件名称一致
• 外部的接口只能使用public、默认这两个范围限定词;如果定义内部接口则可以使用4大范围限定词
• 接口实际上提供了同一的操作界面(方法),如果是JDK1.8-版本则一个方法也不实现,等待某类或某几个类去实现它的方法【接口中的所有方法必须是抽象的】。如果使用的是JDK1.8+允许使用default在接口中定义默认实现,这个实现允许在实现类中重新定义覆盖

public class Test1 {
public static void main(String[] args) {
IA2 a2=new A2Impl();
a2.pp();
}
}
interface IA2 {
default void pp(){ //通过defaul在接口中定义方法的默认实现,则在实现类中可以覆盖定义,也可以继承使用
System.out.println("this is pp....");
this.ff();
}
void ff();
}
class A2Impl implements IA2{
public void ff() {
System.out.println("this is ff...");
}
}

default默认方法实现使用的限制

public class Test1 {
public static void main(String[] args) {
IA2 a2 = new A2Impl();
a2.pp();
}
}
interface IA2 {
default void pp() {
System.out.println("this is No2 pp....");
}
}
interface IA3 {
default void pp(){
System.out.println("this is No3 pp");
}
}
class A2Impl implements IA2, IA3 {//如果IA2中有一个default实现的方法和IA3中的方法一致,则必须在实现类中重新定义
public void pp() {
IA2.super.pp();//调用IA2接口中的pp方法的默认实现
IA3.super.pp();
}
}

• 接口中没有属性,只能定义常量,它提供一些常量,实现它的类可以共享这些常量
• 接口可以给出访问控制符,用public修饰的是公共接口,到处可见;如果定义接口没有范围限定词,则只能在同包中访问

接口中只能定义常量和抽象方法

接口中只能定义公共的常量,接口中的属性默认是public static nal类型的,必须是public static nal类型的

interface IA{
String name="lhz";这里实际上是常量定义,不是属性,它的限定词是public static final
String name="lhz",必须在声明的同时进行赋值
}
在接口中不能定义静态块
接口中不能定义构造器

• 接口中只能定义公共的抽象方法, 只有在JDK1.8+中可以使用default关键字定义方法实现。接口中的方法默认是public abstract类型的,而且必须是public abstract类型的。只有在JDK1.8+中可以使用default关键字定义方法默认实现,同时允许在实现类中覆盖重新定义
• 接口不能被实例化,只能通过实现类所实现,但是可以用于声明变量的类型。
  接口 变量名=new 实现接口类();
• 接口没有构造函数
• 接口中的抽象方法必须在非抽象子类中提供实现,这个实现可以是继承来的

一个类实现接口的语法

class 类名称 implements 接口名称{}

接口抽象方法的默认修饰符为public,在实现接口时必须用public关键字在方法头上说明

interface IA2 {
void pp();
}
class B2 implements IA2 {
void pp() {
}
语法报错,因为IA2接口中的方法为public abstract
}

• 一个接口可以被多个子类实现。一个子类还可以实现多个接口

类实现接口

• 一个类在实现某接口的抽象方法时,必须使用完全相同的方法头public
• 如果一个类实现多接口,用逗号隔开
• 如果一个类实现了声明相同方法的两个接口,则被多个接口共用

public class Test1 {
public static void main(String[] args) {
IA2 a2=new B2(); a2.pp();
IA3 a3=new B2(); a3.pp();
}
}
interface IA2 {
void pp();
}
interface IA3{
void pp();
}
class B2 implements IA2,IA3 {
public void pp() {
System.out.println("this is B2.pp()");
}
}

• 类在实现接口时可以定义它自己的附加成员,这是最常见的形式

public class Test1 {
public static void main(String[] args) {
IA2 a2=new B2();
a2.pp();//这里不能直接调用B2实现类中的其它方法,如果需要调用则应该进行强制类型转换
((B2)a2).dd();
}
}
interface IA2 {
void pp();
}
class B2 implements IA2 {
public void pp() {
System.out.println("this is B2.pp()");
}
private int age=100;
public void pp(int k){
System.out.println("this is pp(int)");
}
public void dd(){
System.out.println("this is dd()");
}
}

• 如果一个类不完全实现接口的所有方法,必须把类定义成abstract类型的类,任何继承该类的子类必须实现该接口

接口中常量

可以为多个接口的实现类共享常量

public class Test1 {
public static void main(String[] args) {
System.out.println(IA2.PI);//可以直接使用
A3 a=new A3();
a.setR(4);
System.out.println(a.getArea());
}
}
interface IA2 {
double PI=3.1415;
} 
class A3 implements IA2{
private double r;
public double getArea(){
//在实现类中也可以直接使用
return PI*r*r;
}
public void setR(double r) {
this.r = r;
}
}

• 只需在接口中定义并赋值,此后不能再修改
• 在类中说明是接口的实现类,就可以使用该接口的常量了

一个对象往往有多重身份

• Java中一个子类只能继承一个父类 (不能表示)
• java中一个类可以实现多个接口。(可以表示)

class 类名称 implements 接口1,接口2, ... {}

• 通过继承和运行时多态的双重机制,可以定义一个被很多不同却有关的对象类型的运用的一致的接口
• 维持抽象接口,甚至不需要重新编译,就可以调用新类的实例

public void 出差(会飞的obj){obj.起飞(); ...}

调用的时候可以传入不能类型的对象
出差(new 飞机());--- 出差(new 鸟());

接口的特殊特征

• 一个类只能有一个父类!
• 一个类可以实现多个接口!
• 一个接口可以继承多个接口

interface 接口名 extends 接口名称1 ,父接口名称2 , ...{}

接口的作用

• 统一访问

接口 obj=new 实现1();  可以还有实现2,实现3等
obj只能调用接口中定义的方法

• 解耦 通过接口可以隔离具体实现
  解耦就是 在使用者 和 实现者 之间没有关系。 无论实现者如何改变实现,对于使用者使用不会变化

接口和抽象类的异同点

• 相同点:都是不断向上抽取而来的
• 不同点:
  • 抽象类需要被继承,而且只能单继承
  • 接口需要被实现,而且可以多实现
  • 抽象类中可以定义抽象方法和非抽象方法,子类继承后可以直接使用非抽象方法
  • 接口中只能定义抽象方法,必须由子类去实现;JDK1.8+中允许接口中的方法有默认实现,实现类中可以直接使用默认实现,允许覆盖定义
  • 抽象类的继承是is a关系,在定义该体系的基本共性内容
  • 接口的实现是like a关系,在定义体系额外功能
  • 接口中只能定义常量,而且必须被初始化,抽象类中可以定义属性,允许在声明时直接初始化,也可以不初始化,同时允许定义常量

接口中的方法必须全部是抽象的(JDK1.8+版本中可以通过default关键字定义方法的默认实现,允许定义静态方
法),抽象类中可以有抽象方法也可以有普通方法

如何使用接口

一般使用接口隔离具体实现,可以将类之间的相互依赖变为类对接口的依赖。例如出差类和会飞的东西是通过会飞的接口进行隔离,这样不管出差类需要修改或者会飞的东西需要修改,都不会相互影响

如果一组相关的类中有公共的方法和特殊的方法,可以使用抽象类,在抽象类中固化公共的方法,而无需具体子类
重复实现;但是在抽象类中无法实现的方法可以延迟到子类中再实现。例如排序器BubbleSorter,其中抽象类
BubbleSorter固化了所使用的冒泡排序算法,而将无法实现的bigger比较算法延迟到BubbleSorter的子类
PigSorter中实现,同时PigSorter中也不需要重新定义排序算法
(先定义接口规范调用方法,在使用抽象类实现接口定义公共方法,最后再定义具体子类实现所有的方法)

内部类

一个类或者接口定义在另外一个类或者接口的内部

public class A1{//外部类
class B1{}//内部类
interface C1{}//内部接口
}

将一个类定义置入另一个类定义中,这就叫作“内部类”

• 内部类之外的类称为外部类
• 内部类的名称必须区别于它所在的外部类,和其它类之间没有要求

//内部类的全名叫做[外部类名称$内部类名称]
public class A1 {
public class A1{}  //语法报错
class B1{}  //语法正确,默认编译的结果名称为A1$B1.class
}
class B1{}

内部类可以访问其外部类的所有变量和方法

public class A1 {//外部类的范围限定词只能是public或者默认package
private String name;
public class B1 {
//内部类的范围限定词可以是4种
public void pp() {
System.out.println(name);
//可以直接访问外部类的成员
System.out.println(A1.this.name);//这里的A1.this用于表示A1类对象
A1.this.name="ffff";
// System.out.println(this.name);报错的原因是this用于指代当前类的对象,当前类B1中并没有属性name
pp();
//可以直接访问外部类的成员
A1.this.pp();
}
}
private void pp(){}

}

• 外部类不能直接访问内部类的实现细节,可以通过创建内部类对象的方式直接访问,不受限定词的影响
• 内部类比外部类多了private/protected/static三个修饰符,这三个修饰符不能用在外部类上
• 非静态内部类不能拥有静态成员,静态内部类则没有这个限制

public class A{
protected class B1 {
private int age = 99;
{
private static String password="123456";//非静态内部类中不能包含静态属性
static{
public B1() {//允许定义构造器和析构器方法
}
public static void hh(){} //非静态内部类中不允许包含静态方法
}//允许包含非静态代码块
}//非静态内部类中不允许包含静态代码块
}
}

内部类的作用

• 内部类提供更好的封装
• 内部类可以直接访问外部类的私有成员,外部类不能直接访问内部类的成员
• 匿名内部类适合用于创建仅仅使用一次使用的类

内部类相关的设计

• 分析事物时发现该事物描述还有事物,而且这个事物还在访问被描述事物的内容
  例如牛和牛腿
• 如果一个事物离开另外一个事物后则没有任何意义,这种情况下建议使用内部类,不允许其他类访问
• 内部类能直接访问外部类中成员,是因为内部类持有了外部类的引用,即外部类名.this

内部类分类

在 Java 中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。广泛意义上的内部类一般来说包括这四种:成员内部类、局部内部类、匿名内部类和静态内部类。

内部类实际拥有外部类的一个引用,在构造函数中将外部类的引用传递进来。

非静态内部类

public class A1{
protected class B1{}//静态内部类是protected static class B1{}
}

• 在创建非静态内部类对象时,要先创建起相应的外部类对象
• 在任何非静态内部类中,都不能有静态数据、静态方法或者又一个静态内部类
• 注意内部类的可见性范围限制

访问方法:直接访问外部类中内部类中的成员

class B1 {
private String pwd;
private void dd(){}
protected class C1 {
private String name;
private void pp(){
System.out.println(pwd);//内部类可以直接访问外部类中的私有成员
//另外的写法 dd();
//另外的写法 B1.this.pwd
B1.this.dd();
}
}
public void ee(){
//如果需要访问内部类中的成员,则必须首先创建内部类对象
C1 cc=new C1();
//通过构建的内部类对象则可以访问内部类中的私有成员
cc.name="abc";
cc.pp();
}
}

• 外部类.内部类 in=new 外部类().new 内部类();

public class A1 {
public static void main(String[] args) {
B1 b = new B1();
B1.C1 cc=b.new C1();//内部类是否可以访问到,取决于内部类上的范围限定词
}
}
class B1 {
class C1{}
}

• in.内部类方法();

public class A1 {
public static void main(String[] args) {
B1 b = new B1();
B1.C1 cc=b.new C1();
cc.pp(); //是否可以访问pp方法取决于pp方法的范围限定词
}
}
class B1 {
class C1{
public void pp(){}
}
}

• 注意内部类的可见性范围限制

class B1 {
private class C1{//这个C1类只能在B1类中进行使用,其它位置不可见
public void pp(){}
}
}

静态内部类

• 静态内部类中,可以有静态数据、静态方法或者又一个静态内部类

class B1 {
static class C1 {// 在静态内部类中才可以定义静态成员
private static int age = 123;
private String pwd="123456";//同时允许定义非静态成员
static {
System.out.println("c1 static...");
}
public static void pp() {
System.out.println("c1 static pp...");
}
public void ff(){//同时允许定义非静态成员
}
static class D1{}
class E1{}
}
}

• 如何使用静态内部类

public class A1 {
public static void main(String[] args) {
B1.C1 cc = new B1.C1();//不需要构建外部类对象,就可以直接创建静态内部类对象,但是是否可见取决于范围限定词
B1.C1.pp();//可以直接访问静态内部类中的静态成员,但是是否可见取决于范围限定词
cc.ff();
}
}

• 静态内部类中,也可以有非静态数据、非静态方法或者又一个非静态内部类
• 静态内部类中,不能访问外部类的非静态成员,这是由Java语法中(静态方法不能直接访问非静态成员)所限定

class B1 {
static class C1 {
}
}
构建内部类对象的方法:
B1.C1 cc = new B1.C1();

以下创建方法错误:
B1 b = new B1();
B1.C1 c = b.new C1();

局部内部类

可以将内部类定义在一个方法或者一个代码块内

public class A1 {
private int age = 123;
public static void main(String[] args) {
A1 aa = new A1();
}
public void pp() {
Date birth = new Date();
// B1 bb=new B1();语法错误,要求局部内部类必须先定义后使用
class B1 { // 局部内部类,只能在所在的{}范围中使用,具备内部类的范围限定词和临时变量一致,只能添加final或者abstract
public void ff() {
System.out.println(age);
A1.this.age = 555;// 可以直接访问外部类中的成员
System.out.println(birth);
// 语法报错,在局部内部类中使用外部的临时变量,则外部临时变量必须是final的,只是final可以省略
// birth = new Date();针对引用类型修改地址是不允许,但是可以修改属性
System.out.println("B1...ff()");
}
}
B1 bb = new B1();
}
}

匿名内部类

匿名内部类就是内部类的简写格式

public class A1 {
public void pp(){
Object obj=new Object(){
@Override//覆盖父类中定义的方法
public String toString() {
return ("anon inner class ... ff");
}
};
System.out.println(obj.toString());//调用匿名内部类中覆盖定义的方法
}
}

匿名内部类的前提是必须继承或者实现一个外部类或者接口

new interfacename(){......};
new superclassname(){......};

如果父类中没有无参构造器,则()中应该有对应的参数
public class A1 {
public void pp(){
new B1(20){
};
//因为B1类中没有无参构造器,必须直接传入参数
}
}
class B1{
private int age;
public B1(int age){
this.age=age;
}
}

• 匿名内部类由于没有名字,所以它没有构造函数
• 如果这个匿名内部类继承了一个只含有带参数构造函数的父类,创建它的时候必须带上这些参数
• 不能定义静态成员

匿名内部类的使用场景

当方法参数是接口类型时,而且接口中的方法不超过三个,可以用匿名内部类作为实际参数进行传递

public interfce IA{
public void cc();
}
public class B{
public void pp(IA a){
}
}
public class Test{
public static void main(String[] args){
B b=new B();
b.pp(new IA(){
public void cc(){}//提供接口IA中的所有抽象方法的实现
});
}
}

匿名内部类的使用限制

• 匿名内部类不能是抽象的
• 匿名内部类不能定义构造器,默认和父类相似的构造器
• JDK1.8-要求给局部内部类、匿名内部类访问的局部变量必须使用 nal修饰,从JDK1.8开始这个现实被取消了,但是默认是 nal的(不能修改)

public void pp() {
final Date birth = new Date();
class C1 {
public void ff() {
System.out.println(birth);
birth.setYear(2000);// 3900
// birth=new Date(); 语法报错
System.out.println("modify year:" + birth);
}
}
new C1().ff();
}

内部类的使用场景和好处

• 每个内部类都能独立的提供一个接口的实现,所以无论外部类是否已经继承了某个(接口的)实现,对于内部类都没有影响。内部类使得多继承的解决方案变得完整
• 方便将存在一定逻辑关系的类组织在一起,又可以对外界隐藏
• 方便编写事件驱动程序
• 方便编写线程代码

btn.addActionListener(new ActionListener() { //添加按钮对应的事件处理
public void actionPerformed(ActionEvent e) {
showNewWindow(mainWin);
}
});