上面我们学习了几个修饰符，在开发中经常会用的到，所以必须熟练的掌握。接下来我学习一下接口和访问控制。
一、接口
一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
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 implements A,B,C,D{ 2 //Student需要实现接口A B C D中所有的抽象方法 3 //否则Student类就要声明为抽象类,因为有抽象方法没实现 4 } 5 main: 6 A s1 = new Student(); 7 B s2 = new Student(); 8 C s3 = new Student(); 9 D s4 = new Student(); 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 = new Student(); 24 s1.test(); 25 26 B s2 = new Student(); 27 s2.run(); 28 29 if(s1 instanceof B){ 30 ((B)s1).run(); 31 }
实例
1.5、一个接口可以继承多个父接口
1 public interface A{ 2 public void testA(); 3 } 4 5 public interface B{ 6 public void testB(); 7 } 8 9 //接口C把接口A B中的方法都继承过来了 10 public interface C extends A,B{ 11 public void testC(); 12 } 13 14 //Student相当于实现了A B C三个接口,需要实现所有的抽象方法 15 //Student的对象也就同时属于A类型 B类型 C类型 16 public class Student implements C{ 17 public viod testA(){} 18 public viod testB(){} 19 public viod testC(){} 20 } 21 22 main: 23 C o = new Student(); 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 package com.frewen.interfacedemo; 2 3 interface SwimInterface{ 4 void swim(); 5 } 6 class Fish{ 7 int fins=4; 8 } 9 class Duck { 10 int leg=2; 11 void egg(){}; 12 } 13 14 class Goldfish extends Fish implements SwimInterface { 15 @Override 16 public void swim() { 17 System.out.println("Goldfish can swim "); 18 } 19 } 20 21 class SmallDuck extends Duck implements SwimInterface { 22 public void egg(){ 23 System.out.println("SmallDuck can lay eggs "); 24 } 25 @Override 26 public void swim() { 27 System.out.println("SmallDuck can swim "); 28 } 29 } 30 31 public class InterfaceDemo { 32 public static void main(String[] args) { 33 Goldfish goldfish=new Goldfish(); 34 goldfish.swim(); 35 36 SmallDuck smallDuck= new SmallDuck(); 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 class Test{ 2 private class A{} 3 class B{} 4 protected class C{} 5 public class D{} 6 } 7 8 class Action{} 9 10 //编译报错 11 protected class Action2{} 12 private class Action3{}
2）内部类
四个修饰符可以修饰特定的内部类
1 //四个内部类 2 public class Test{ 3 private class A{} 4 class B{} 5 protected class C{} 6 public class D{} 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
注:这里的子类中默认指的是不同包下面的子类
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/12420.html