做外贸的在哪些网站找工作,找网站做,php p2p网站建设,开发公司是什么访问权限Java 中有三个访问权限修饰符#xff1a;private、protected 以及 public#xff0c;如果不加访问修饰符#xff0c;表示包级可见。可以对类或类中的成员(字段和方法)加上访问修饰符。类可见表示其它类可以用这个类创建实例对象。成员可见表示其它类可以用这个类的实…访问权限Java 中有三个访问权限修饰符private、protected 以及 public如果不加访问修饰符表示包级可见。可以对类或类中的成员(字段和方法)加上访问修饰符。类可见表示其它类可以用这个类创建实例对象。成员可见表示其它类可以用这个类的实例对象访问到该成员protected 用于修饰成员表示在继承体系中成员对于子类可见但是这个访问修饰符对于类没有意义。设计良好的模块会隐藏所有的实现细节把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信一个模块不需要知道其他模块的内部工作情况这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。如果子类的方法重写了父类的方法那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例去代替也就是确保满足里氏替换原则。字段决不能是公有的因为这么做的话就失去了对这个字段修改行为的控制客户端可以对其随意修改。例如下面的例子中AccessExample 拥有 id 公有字段如果在某个时刻我们想要使用 int 存储 id 字段那么就需要修改所有的客户端代码。public class AccessExample {public String id;}可以使用公有的 getter 和 setter 方法来替换公有字段这样的话就可以控制对字段的修改行为。public class AccessExample {private int id;public String getId() {return id ;}public void setId(String id) {this.id Integer.valueOf(id);}}但是也有例外如果是包级私有的类或者私有的嵌套类那么直接暴露成员不会有特别大的影响。public class AccessWithInnerClassExample {private class InnerClass {int x;}private InnerClass innerClass;public AccessWithInnerClassExample() {innerClass new InnerClass();}public int getValue() {return innerClass.x; // 直接访问}}抽象类与接口1. 抽象类抽象类和抽象方法都使用 abstract 关键字进行声明。如果一个类中包含抽象方法那么这个类必须声明为抽象类。抽象类和普通类最大的区别是抽象类不能被实例化只能被继承。public abstract class AbstractClassExample {protected int x;private int y;public abstract void func1();public void func2() {System.out.println(func2);}}public class AbstractExtendClassExample extends AbstractClassExample {Overridepublic void func1() {System.out.println(func1);}}// AbstractClassExample ac1 new AbstractClassExample(); // AbstractClassExample is abstract; cannot be instantiatedAbstractClassExample ac2 new AbstractExtendClassExample();ac2.func1();2. 接口接口是抽象类的延伸在 Java 8 之前它可以看成是一个完全抽象的类也就是说它不能有任何的方法实现。从 Java 8 开始接口也可以拥有默认的方法实现这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前如果一个接口想要添加新的方法那么要修改所有实现了该接口的类让它们都实现新增的方法。接口的成员(字段 方法)默认都是 public 的并且不允许定义为 private 或者 protected。从 Java 9 开始允许将方法定义为 private这样就能定义某些复用的代码又不会把方法暴露出去。接口的字段默认都是 static 和 final 的。public interface InterfaceExample {void func1();default void func2(){System.out.println(func2);}int x 123;// int y; // Variable y might not have been initializedpublic int z 0; // Modifier public is redundant for interface fields// private int k 0; // Modifier private not allowed here// protected int l 0; // Modifier protected not allowed here// private void fun3(); // Modifier private not allowed here}public class InterfaceImplementExample implements InterfaceExample {Overridepublic void func1() {System.out.println(func1);}}// InterfaceExample ie1 new InterfaceExample(); // InterfaceExample is abstract; cannot be instantiatedInterfaceExample ie2 new InterfaceImplementExample();ie2.func1();System.out.println(InterfaceExample.x);3. 比较从设计层面上看抽象类提供了一种 IS-A 关系需要满足里式替换原则即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系它只是提供一种方法实现契约并不要求接口和实现接口的类具有 IS-A 关系。从使用上来看一个类可以实现多个接口但是不能继承多个抽象类。接口的字段只能是 static 和 final 类型的而抽象类的字段没有这种限制。接口的成员只能是 public 的而抽象类的成员可以有多种访问权限。4. 使用选择使用接口需要让不相关的类都实现一个方法例如不相关的类都可以实现 Comparable 接口中的 compareTo() 方法需要使用多重继承。使用抽象类需要在几个相关的类中共享代码。需要能控制继承来的成员的访问权限而不是都为 public。需要继承非静态和非常量字段。在很多情况下接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求可以灵活地为一个类添加行为。并且从 Java 8 开始接口也可以有默认的方法实现使得修改接口的成本也变的很低。super访问父类的构造函数可以使用 super() 函数访问父类的构造函数从而委托父类完成一些初始化的工作。应该注意到子类一定会调用父类的构造函数来完成初始化工作一般是调用父类的默认构造函数如果子类需要调用父类其它构造函数那么就可以使用 super() 函数。访问父类的成员如果子类重写了父类的某个方法可以通过使用 super 关键字来引用父类的方法实现。public class SuperExample {protected int x;protected int y;public SuperExample(int x, int y) {this.x x;this.y y;}public void func() {System.out.println(SuperExample.func());}}public class SuperExtendExample extends SuperExample {private int z;public SuperExtendExample(int x, int y, int z) {super(x, y);this.z z;}Overridepublic void func() {super.func();System.out.println(SuperExtendExample.func());}}SuperExample e new SuperExtendExample(1, 2, 3);e.func();SuperExample.func()SuperExtendExample.func()重写与重载1. 重写(Override)存在于继承体系中指子类实现了一个与父类在方法声明上完全相同的一个方法。为了满足里式替换原则重写有以下三个限制子类方法的访问权限必须大于等于父类方法子类方法的返回类型必须是父类方法返回类型或为其子类型。子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。使用 Override 注解可以让编译器帮忙检查是否满足上面的三个限制条件。下面的示例中SubClass 为 SuperClass 的子类SubClass 重写了 SuperClass 的 func() 方法。其中子类方法访问权限为 public大于父类的 protected。子类的返回类型为 ArrayList是父类返回类型 List 的子类。子类抛出的异常类型为 Exception是父类抛出异常 Throwable 的子类。子类重写方法使用 Override 注解从而让编译器自动检查是否满足限制条件。class SuperClass {protected List func() throws Throwable {return new ArrayList();}}class SubClass extends SuperClass {Overridepublic ArrayList func() throws Exception {return new ArrayList();}}在调用一个方法时先从本类中查找看是否有对应的方法如果没有再到父类中查看看是否从父类继承来。否则就要对参数进行转型转成父类之后看是否有对应的方法。总的来说方法调用的优先级为this.func(this)super.func(this)this.func(super)super.func(super)/*A|B|C|D*/class A {public void show(A obj) {System.out.println(A.show(A));}public void show(C obj) {System.out.println(A.show(C));}}class B extends A {Overridepublic void show(A obj) {System.out.println(B.show(A));}}class C extends B {}class D extends C {}public static void main(String[] args) {A a new A();B b new B();C c new C();D d new D();// 在 A 中存在 show(A obj)直接调用a.show(a); // A.show(A)// 在 A 中不存在 show(B obj)将 B 转型成其父类 Aa.show(b); // A.show(A)// 在 B 中存在从 A 继承来的 show(C obj)直接调用b.show(c); // A.show(C)// 在 B 中不存在 show(D obj)但是存在从 A 继承来的 show(C obj)将 D 转型成其父类 Cb.show(d); // A.show(C)// 引用的还是 B 对象所以 ba 和 b 的调用结果一样A ba new B();ba.show(c); // A.show(C)ba.show(d); // A.show(C)}2. 重载(Overload)存在于同一个类中指一个方法与已经存在的方法名称上相同但是参数类型、个数、顺序至少有一个不同。应该注意的是返回值不同其它都相同不算是重载。class OverloadingExample {public void show(int x) {System.out.println(x);}public void show(int x, String y) {System.out.println(x y);}}public static void main(String[] args) {OverloadingExample example new OverloadingExample();example.show(1);example.show(1, 2);}
