java接口 详解 二_JavaSE（四）之接口、访问控制详解

上面我们学习了几个修饰符，在开发中经常会用的到，所以必须熟练的掌握。接下来我学习一下接口和访问控制。

一、接口

一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。

1.1、接口与抽象类的区别

抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。接口已经另一种类型了,和类是有本质的区别的,所有不能用类的标准去衡量接口。

声明类的关键字是class,声明接口的关键字是interface。

抽象类是用来被继承的,java中的类是单继承。

类A继承了抽象类B,那么类A的对象就属于B类型了,可以使用多态

一个父类的引用,可以指向这个父类的任意子类对象

注:继承的关键字是extends

接口是用来被类实现的,java中的接口可以被多实现。

类A实现接口B、C、D、E..,那么类A的对象就属于B、C、D、E等类型了,可以使用多态

一个接口的引用,可以指向这个接口的任意实现类对象

注:实现的关键字是implements

1.2、接口中的方法都是抽象方法

接口中可以不写任何方法,但如果写方法了,该方法必须是抽象方法

例如:

public interface Action{

public abstract void run();

//默认就是public abstract修饰的

void test();

public void go();

}

1.3、接口中的变量都是静态常量(public static final修饰)

接口中可以不写任何属性,但如果写属性了,该属性必须是public static final修饰的静态常量。

注:可以直接使用接口名访问其属性。因为是public static修饰的

例如:

注:声明的同时就必须赋值.(因为接口中不能编写静态代码块)

public interface Action{

public static final String NAME = "tom";

//默认就是public static final修饰的

int AGE = 20;

}

main:

System.out.println(Action.NAME);

System.out.println(Action.AGE);

1.4、一个类可以实现多个接口

1 public class Student implementsA,B,C,D{2 //Student需要实现接口A B C D中所有的抽象方法3 //否则Student类就要声明为抽象类,因为有抽象方法没实现

4 }5 main:6 A s1 = newStudent();7 B s2 = newStudent();8 C s3 = newStudent();9 D s4 = newStudent();10

11 注:12 s1只能调用接口A中声明的方法以及Object中的方法13 s2只能调用接口B中声明的方法以及Object中的方法14 s3只能调用接口C中声明的方法以及Object中的方法15 s4只能调用接口D中声明的方法以及Object中的方法16

17 注:必要时可以类型强制转换18

19 例如:20 接口A 中有test()21 接口B 中有run()22

23 A s1 = newStudent();24 s1.test();25

26 B s2 = newStudent();27 s2.run();28

29 if(s1 instanceofB){30 ((B)s1).run();31 }

实例

1.5、一个接口可以继承多个父接口

1 public interfaceA{2 public voidtestA();3 }4

5 public interfaceB{6 public voidtestB();7 }8

9 //接口C把接口A B中的方法都继承过来了

10 public interface C extendsA,B{11 public voidtestC();12 }13

14 //Student相当于实现了A B C三个接口,需要实现所有的抽象方法15 //Student的对象也就同时属于A类型 B类型 C类型

16 public class Student implementsC{17 publicviod testA(){}18 publicviod testB(){}19 publicviod testC(){}20 }21

22 main:23 C o = newStudent();24 System.out.println(o instanceof A);//true

25 System.out.println(o instanceof B);//true

26 System.out.println(o instanceof C);//true

27 System.out.println(o instanceof Student);//true

28 System.out.println(o instanceof Object);//true

29 System.out.println(o instanceof Teacher);//false

实例

//编译报错

System.out.println(o instanceof String);

注:

System.out.println(o instanceof X);

如果o是一个接口类型声明的变量,那么只要X不是一个final修饰的类,该代码就能通过编译,至于其结果是不是true,就要看变量o指向的对象的实际类型,是不是X的子类或者实现类了。

注:一个引用所指向的对象,是有可能实现任何一个接口的。(java中的多实现)

1.6、接口的作用

接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建，【接口名】 【对象名】=new 【实现接口的类】，这样你像用哪个类的对象就可以new哪个对象了，不需要改原来的代码。

假如我们两个类中都有个function()的方法，如果我用接口，那样我new a()；就是用a的方法，new b()就是用b的方法

这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同

总结：

1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)

2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化

3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法

4、接口中没有构造方法,不能被实例化

5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口

6、Java接口必须通过类来实现它的抽象方法

7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类

8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例

9、  一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.

1.7、实例

1 packagecom.frewen.interfacedemo;2

3 interfaceSwimInterface{4 voidswim();5 }6 classFish{7 int fins=4;8 }9 classDuck {10 int leg=2;11 voidegg(){};12 }13

14 class Goldfish extends Fish implementsSwimInterface {15 @Override16 public voidswim() {17 System.out.println("Goldfish can swim ");18 }19 }20

21 class SmallDuck extends Duck implementsSwimInterface {22 public voidegg(){23 System.out.println("SmallDuck can lay eggs ");24 }25 @Override26 public voidswim() {27 System.out.println("SmallDuck can swim ");28 }29 }30

31 public classInterfaceDemo {32 public static voidmain(String[] args) {33 Goldfish goldfish=newGoldfish();34 goldfish.swim();35

36 SmallDuck smallDuck= newSmallDuck();37 smallDuck.swim();38 smallDuck.egg();39 }40 }

二、访问控制

public protected default private是java中的访问控制修饰符.

注:这里的default的意思是什么都不写

例如:

public String name;

protected String name;

//default就表示这种情况

String name;

private String name;

2.1、修饰类

1)普通类

只能使用public和default来修饰源文件中编写的java类

public表示其他任何地方都有权限访问这个类

default表示只有和当前类在同一个包的类才有权限访问

例如: Test.java中有俩个类

1 public classTest{2 private classA{}3 classB{}4 protected classC{}5 public classD{}6 }7

8 classAction{}9

10 //编译报错

11 protected classAction2{}12 private class Action3{}

2)内部类

四个修饰符可以修饰特定的内部类

1 //四个内部类

2 public classTest{3 private classA{}4 classB{}5 protected classC{}6 public classD{}7 }

2.2、修饰属性和方法

四个修饰都可以修饰类中的属性和方法,那么就以修饰属性为例来说明.(效果和修饰方法是一样的)

public class Person{

public      String pubStr = "pubStr";

protected String proStr = "proStr";

String defStr = "defStr";

private   String priStr = "priStr";

}

从四个地方测试这些属性的可见性:

类中     同包类中    子类中    不同包类中

public         Y            Y            Y            Y

protected     Y            Y            Y            N

default         Y            Y            N            N

private         Y            N            N            N

注:这里的子类中默认指的是不同包下面的子类