五泉山网页设计宣传网站制作,兰州优化定制,成都高新区规划国土建设局网站,枣庄网站优化2019独角兽企业重金招聘Python工程师标准 Java中接口、抽象类与内部类学习 接口与内部类为我们提供了一种将接口与实现分离的更加结构化的方法。 抽象类和抽象方法 抽象方法#xff1a;仅有声明而没有方法体。 抽象类#xff1a;包含一个或多个抽象方法的类 Java中接口、抽象类与内部类学习 接口与内部类为我们提供了一种将接口与实现分离的更加结构化的方法。 抽象类和抽象方法 抽象方法仅有声明而没有方法体。 抽象类包含一个或多个抽象方法的类该类就必须限定为抽象的否则会报错。 abstract void f() { //抽象方法 }抽象类的特点 抽象类中的方法并不需要所有的方法都是抽象的只需部分的方法是抽象的即可。如果一个新类从一个抽象类继承并想创建该新类的对象name就必须为基类中所有的抽象方法提供方法定义。否则导出类也是抽象类并要用abstract修饰该类。抽象类并不能被实例化。抽象类中的抽象方法不能有方法体但抽象类中的其它非抽象方法必须有方法体。抽象类中也可以没有抽象方法。抽象类中不应该有private的成员注意是不应该而不是不能。不管是成员变量还是非抽象方法都不建议用private修饰抽象方法是禁止使用private修饰。原因就是我们创建抽象类的目的就是要实现代码复用方便子类继承private修饰的是不能继承的同时抽象类不能实例化对象所以用private修饰的成员毫无用处。抽象类的中抽象方法只允许用public和默认修饰JDK1.8之前默认是用protected修饰但在JDK1.8之后则是默认为default修饰 接口 interface关键字使抽象的概念更向前了一步。interface将产生一个完全抽象的类没有提供任何具体实现。 接口的特点 允许创建者确定方法名、参数列表和返回类型。但是没有任何方法体。接口只提供了形式并没有提供任何具体实现。接口中可以包含域如intString但是域默认是static、final的。即默认定为public static final类型的。接口中的方法必须是public修饰的默认为public。接口中的方法不能有方法体。接口中定义的方法都需要有实现类来实现如果实现类不能实现接口中的所有方法则实现类定义为抽象类。接口中的方法可以为static int method即defalut static修饰但是默认修饰方法的还是public abstarct的在接口中只有方法的声明没有方法体。接口与抽象类的使用判断 若要创建不带任何方法定义及成员变量的基类则选择接口注意接口中没有成员变量只有public static final修饰的常量且符号要大写若知道某事物应该成为一个基类则第一选择应是使它成为一个接口。 完全解耦—接口的应用p174 Java中的多重继承 可以通过接口实现Java的多继承当将一个具体类和多个接口组合到一起时这个具体类必须放在前面后面跟着的才是接口否则编译器会报错。 interface CanFight{void fight(); } interface CanSwim{void swim(); } interface CanFly{void fly(); } class ActionCharacter{public void fight(){} } class Hero extends ActionCharacter implements CanFight,CanFly,CanSwim {public void swim() {}public void fly() {} } public class Adventrue {private static void t(CanFight x){x.fight(); }private static void u(CanSwim x){x.swim(); }private static void v(CanFly x){x.fly(); }private static void w(ActionCharacter x){x.fight(); }public static void main(String [] args){Hero hero new Hero();t(hero);u(hero);v(hero);w(hero);} }使用接口的核心原因 为了能够向上转型为多个基类型由此带来的灵活性防止客户端程序员创建该类的对象并确保这仅仅是建立一个接口 通过继承来扩展接口 适配接口 接口中的域 初始化接口中的域 在接口中定义的域不能是”空final“但是可以被非常量的表达式初始化。例如int RANM_INT Rand.nextInt(10);.因为域是static的可以在域第一次加载时就初始化当然这些域不是接口的一部分他们的值被存在该接口的静态储存区域中。 嵌套接口 接口可以嵌套在类或其他接口中。 接口与工厂 内部类补 为什么使用内部类 使用内部类最吸引人的原因是每个内部类都能独立地继承一个接口的实现所以无论外围类是否已经继承了某个接口的实现对于内部类都没有影响 使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,使用内部类还能够为我们带来如下特性: 　　(1)、内部类可以用多个实例每个实例都有自己的状态信息并且与其他外围对象的信息相互独。 　　(2)、在单个外围类中可以让多个内部类以不同的方式实现同一个接口或者继承同一个类。 　　(3)、创建内部类对象的时刻并不依赖于外围类对象的创建。 　　(4)、内部类并没有令人迷惑的“is-a”关系他就是一个独立的实体。 　　(5)、内部类提供了更好的封装除了该外围类其他类都不能访问。 内部类分类 成员内部类 public class Outer{private int age 99;String name Coco;public class Inner{String name Jayden;public void show(){System.out.println(Outer.this.name);System.out.println(name);System.out.println(age);}}public Inner getInnerClass(){return new Inner();}public static void main(String[] args){Outer o new Outer();Inner in o.new Inner();in.show();}}1.Inner 类定义在 Outer 类的内部相当于 Outer 类的一个成员变量的位置Inner 类可以使用任意访问控制符 如 public 、 protected 、 private 等 2.Inner 类中定义的 show() 方法可以直接访问 Outer 类中的数据而不受访问控制符的影响 如直接访问 Outer 类中的私有属性age 3.定义了成员内部类后必须使用外部类对象来创建内部类对象而不能直接去 new 一个内部类对象 即内部类 对象名 外部类对象.new 内部类( ); 4.编译上面的程序后会发现产生了两个 .class 文件: Outer.class,Outer$Inner.class{} 5.成员内部类中不能存在任何 static 的变量和方法,可以定义常量: (1).因为非静态内部类是要依赖于外部类的实例,而静态变量和方法是不依赖于对象的,仅与类相关, 简而言之:在加载静态域时,根本没有外部类,所在在非静态内部类中不能定义静态域或方法,编译不通过; 非静态内部类的作用域是实例级别 (2).常量是在编译器就确定的,放到所谓的常量池了 ★★友情提示: 1.外部类是不能直接使用内部类的成员和方法的可先创建内部类的对象然后通过内部类的对象来访问其成员变量和方法; 2.如果外部类和内部类具有相同的成员变量或方法内部类默认访问自己的成员变量或方法如果要访问外部类的成员变量 可以使用 this 关键字,如:Outer.this.name 静态内部类 是 static 修饰的内部类 1.静态内部类不能直接访问外部类的非静态成员但可以通过 new 外部类().成员 的方式访问 2.如果外部类的静态成员与内部类的成员名称相同可通过“类名.静态成员”访问外部类的静态成员 如果外部类的静态成员与内部类的成员名称不相同则可通过“成员名”直接调用外部类的静态成员 3.创建静态内部类的对象时不需要外部类的对象可以直接创建 内部类 对象名 new 内部类(); public class Outer{private int age 99;static String name Coco;public static class Inner{String name Jayden;public void show(){System.out.println(Outer.name);System.out.println(name); }}public static void main(String[] args){Inner i new Inner();i.show();}}.方法内部类 访问仅限于方法内或者该作用域内 (1).局部内部类就像是方法里面的一个局部变量一样是不能有 public、protected、private 以及 static 修饰符的 (2).只能访问方法中定义的 final 类型的局部变量,因为: 当方法被调用运行完毕之后局部变量就已消亡了。但内部类对象可能还存在, 直到没有被引用时才会消亡。此时就会出现一种情况就是内部类要访问一个不存在的局部变量; 使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期. 局部内部类并不是直接调用方法传进来的参数而是内部类将传进来的参数通过自己的构造器备份到了自己的内部 自己内部的方法调用的实际是自己的属性而不是外部类方法的参数; 防止被篡改数据,而导致内部类得到的值不一致 /* 使用的形参为何要为 final??? 在内部类中的属性和外部方法的参数两者从外表上看是同一个东西但实际上却不是所以他们两者是可以任意变化的 也就是说在内部类中我对属性的改变并不会影响到外部的形参而然这从程序员的角度来看这是不可行的 毕竟站在程序的角度来看这两个根本就是同一个如果内部类该变了而外部方法的形参却没有改变这是难以理解 和不可接受的所以为了保持参数的一致性就规定使用 final 来避免形参的不改变 */public class Outer{public void Show(){final int a 25;int b 13;class Inner{int c 2;public void print(){System.out.println(访问外部类: a);System.out.println(访问内部类: c);}}Inner i new Inner();i.print();}public static void main(String[] args){Outer o new Outer();o.show();}} (3).注意:在JDK8版本之中,方法内部类中调用方法中的局部变量,可以不需要修饰为 final,匿名内部类也是一样的主要是JDK8之后增加了 Effectively final 功能http://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html 反编译jdk8编译之后的class文件,发现内部类引用外部的局部变量都是 final 修饰的 匿名内部类 (1).匿名内部类是直接使用 new 来生成一个对象的引用; (2).对于匿名内部类的使用它是存在一个缺陷的就是它仅能被使用一次创建匿名内部类时它会立即创建一个该类的实例 该类的定义会立即消失所以匿名内部类是不能够被重复使用; (3).使用匿名内部类时我们必须是继承一个类或者实现一个接口但是两者不可兼得同时也只能继承一个类或者实现一个接口; (4).匿名内部类中是不能定义构造函数的,匿名内部类中不能存在任何的静态成员变量和静态方法; (5).匿名内部类中不能存在任何的静态成员变量和静态方法,匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法 (6).匿名内部类初始化:使用构造代码块利用构造代码块能够达到为匿名内部类创建一个构造器的效果 public class OuterClass {public InnerClass getInnerClass(final int num,String str2){return new InnerClass(){int number num 3;public int getNumber(){return number;}}; /* 注意分号不能省 */}public static void main(String[] args) {OuterClass out new OuterClass();InnerClass inner out.getInnerClass(2, chenssy);System.out.println(inner.getNumber());}}interface InnerClass {int getNumber();} 内部类 可以将一个类的定义放在另一个类的定义内部这就是内部类。内部类的使用与其他类没有什么不同但是如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象时那么必须指明这个对象的类型OuterClassName.InnerClassName。 public class Parcel2 {class Contents {private int i 11;public int value() {return i;}}class Destination{private String label;Destination(String whereTo){label whereTo;}String readLable(){return label;}}public Contents contents(){ return new Contents(); }public Destination destination(String s){ return new Destination(s); }public void ship(String dest){Contents c new Contents();Destination d new Destination(dest);System.out.println(d.readLable());}public static void main(String [] args){Parcel2 p new Parcel2();p.ship(Tasmania);//defing references to inner classParcel2 q new Parcel2();Parcel2.Contents c q.contents();Parcel2.Destination d q.destination(borneo);} }内部类标识符 外围内的名字 “$” 内部类的名字.class。如果内部类是匿名的编译器会简单地产生一个数字作为其标识符。如果内部类是嵌套在别的内部类中只需直接将他们的名字加在其外围类标识符与“$”后面。 链接到外部类 当生成一个内部类对象时此对象与制造它的外围对象之间就有了一种联系所以他就能访问其外围对象的所有成员而不需要任何其他条件。内部类拥有其外围类的所有元素的访问权。内部类的对象只能在与外围类的对象相关联的情况下才能被创建。构建一个内部类时需要一个指向其外围类对象的引用如果编译器找不到这个引用则会报错。外部类访问内部类可以通过几种方式访问 方式一外部类name.内部类name name 外部类对象.get方法返回内部类new的对象。如 Parcel2.Contents c q.contents();要求在外部类的contents方法中要返回内部类的new对象。 方式二内部类实现了外部的一个接口则可以 interface name 外部类.get方法返回内部类的对象。都不能直接在外部类中采用new字段去构造对象再访问可以用封装在外部类的方法中再new内部类后用方法返回。 方式三通过.new去创建 使用.this和.new 要生成对外部类的引用可以再外部类的名字后紧跟”.this“。这样产生的引用具有正确的类型且在编译期就被知晓并检查因此没有任何运行时的开销。 public class DoThis {void f(){ System.out.println(DoThis.f()); }public class Inner{public DoThis outer(){ return DoThis.this; } //返回外部类的引用}public Inner inner(){ return new Inner(); }public static void main(String [] args){DoThis dt new DoThis();DoThis.Inner di dt.inner();di.outer().f();} }创建某个内部类的对象使用“.new”。要创建某个类的对象必须使用外部内的对象来创建该内部类的对象。在拥有外部类对象之前是不可能创建内部类对象的因为内部类会暗暗地连接到引用它的外部类对象上。但是如果创建的是嵌套类静态内部类那么就不需要对外部类对象的引用。 public class DoNew {public class Inner{}public static void main(String [] args){DoNew dn new DoNew();DoNew.Inner di dn.new Inner();} }内部类与向上转型 当将内部类向上转型为其基类尤其是转型为一个接口时内部类就发挥很大作用了。因为内部类——某个借口的实现——能够完全不可见并且不可用。所以得到得只是指向基类或接口的引用能够很方便的隐藏实现细节。 在方法和作用域内的内部类 可以在一个方法里面或者在任意的作用域内定义内部类。 实现某个类型的接口于是可以创建并返回对其的引用。想创建一个类来辅助解决问题但不希望这个类是公共可用的。 局部内部类 在方法的作用域内创建一个完整的类。在方法的作用域外是不能访问的。在方法执行完毕并不意味着局部内部类就不可以使用了。可以在同一个子目录的任意类中对局部内部类使用相同的类标识符这并不会引起命名冲突。 匿名内部类 将返回值的生成与表示这个返回值的类的定义结合在一起。这个类是没有名字的。 public class Parcel7 {public Contens contens(){return new Contens() {private int i 11;public int value() {return i;}};}public static void main(String [] args){Parcel7 p new Parcel7();Contens c p.contens();} }匿名内部类的基类如果只有带参构造器在使用匿名类时可以传递合适的参数给基类的构造器即可。 public class Parcel8 {public Wrappping wrappping(int x) {return new Wrappping(x) {public int value() {System.out.println(super.value(): super.value());return super.value() * 47;}};}public static void main(String[] args) {Parcel8 p new Parcel8();Wrappping wrappping p.wrappping(10);wrappping.value();} }在匿名类的末尾的分号并不是用来标记此内部类结束的它标识的是表达式的结束只不过表达式正好包含了匿名内部类。这与别的地方使用的分号是一致的。在匿名类中定义字段时还可以初始化。如果匿名内部类希望使用一个在其外部定义的对象编译器要求参数引用时final的。这个在jdk以前的版本是这样但是在jdk1.8的时候这一规则不再适用。内部类可以访问外部类中的所有变量无需用final修饰了 public class Parcel9 {public Destination destination( /*final*/ String dest){return new Destination() {private String label dest;public String readLabel() {return label;}};}public static void main(String [] args){Parcel9 p new Parcel9();Destination d p.destination(sdcsd);} }匿名内部类既可以扩展类也可以实现接口但是在实现接口时变不能继承继承时便不能实现接口而且实现接口时只能实现一个接口。 嵌套类 嵌套类不需要内部类对象与其外围类对象有联系那么可以将内部类声明为static。普通的内部类不能有static数据和static字段也不能包含嵌套类。但是嵌套类可以包含所有的这些东西。 接口中的类 接口中的任何类修饰都是public和static的可以在接口中的内部类实现其外围接口。如果想创建某些公共代码使得他们都可以被某个接口的的所有不同实现所共用name使用接口内部的嵌套类会很方便。 转载于:https://my.oschina.net/PrivateO2/blog/1575796