Java中接口、抽象类与内部类学习

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

Java中接口、抽象类与内部类学习

接口与内部类为我们提供了一种将接口与实现分离的更加结构化的方法。

抽象类和抽象方法

抽象方法:仅有声明而没有方法体。
抽象类:包含一个或多个抽象方法的类,该类就必须限定为抽象的(否则会报错)。

abstract void f() {  //抽象方法
}

抽象类的特点:

  1. 抽象类中的方法并不需要所有的方法都是抽象的,只需部分的方法是抽象的即可。
  2. 如果一个新类从一个抽象类继承,并想创建该新类的对象,name就必须为基类中所有的抽象方法提供方法定义。否则导出类也是抽象类,并要用abstract修饰该类。
  3. 抽象类并不能被实例化。
  4. 抽象类中的抽象方法不能有方法体,但抽象类中的其它非抽象方法必须有方法体。
  5. 抽象类中也可以没有抽象方法。
  6. 抽象类中不应该有private的成员(注意是不应该,而不是不能)。不管是成员变量,还是非抽象方法都不建议用private修饰,抽象方法是禁止使用private修饰。原因就是我们创建抽象类的目的就是要实现代码复用,方便子类继承,private修饰的是不能继承的,同时抽象类不能实例化对象,所以用private修饰的成员毫无用处。

抽象类的中抽象方法只允许用public默认修饰(JDK1.8之前默认是用protected修饰,但在JDK1.8之后则是默认为default修饰)

接口(???)

interface关键字使抽象的概念更向前了一步。interface将产生一个完全抽象的类,没有提供任何具体实现。

接口的特点:

  1. 允许创建者确定方法名、参数列表和返回类型。但是没有任何方法体。接口只提供了形式并没有提供任何具体实现。
  2. 接口中可以包含域(如int,String)但是域默认是static、final的。即默认定为public static final类型的。
  3. 接口中的方法必须是public修饰的,默认为public。
  4. 接口中的方法不能有方法体。
  5. 接口中定义的方法都需要有实现类来实现,如果实现类不能实现接口中的所有方法则实现类定义为抽象类。
  6. 接口中的方法可以为static int method();即defalut static修饰;但是默认修饰方法的还是public abstarct的
  7. 在接口中只有方法的声明没有方法体。

接口与抽象类的使用判断:

  1. 若要创建不带任何方法定义及成员变量的基类,则选择接口(注意:接口中没有成员变量,只有public static final修饰的常量,且符号要大写)
  2. 若知道某事物应该成为一个基类,则第一选择应是使它成为一个接口。

完全解耦—接口的应用???(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);}
}

使用接口的核心原因:

  1. 为了能够向上转型为多个基类型(由此带来的灵活性)
  2. 防止客户端程序员创建该类的对象,并确保这仅仅是建立一个接口

通过继承来扩展接口(???)

适配接口(???)

接口中的域

初始化接口中的域

在接口中定义的域不能是”空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。如果内部类是匿名的,编译器会简单地产生一个数字作为其标识符。如果内部类是嵌套在别的内部类中,只需直接将他们的名字加在其外围类标识符与“$”后面。

链接到外部类

  1. 当生成一个内部类对象时,此对象与制造它的外围对象之间就有了一种联系,所以他就能访问其外围对象的所有成员而不需要任何其他条件。内部类拥有其外围类的所有元素的访问权。
  2. 内部类的对象只能在与外围类的对象相关联的情况下才能被创建。构建一个内部类时需要一个指向其外围类对象的引用,如果编译器找不到这个引用则会报错。
  3. 外部类访问内部类可以通过几种方式访问:
    方式一:外部类name.内部类name name = 外部类对象.get方法返回内部类new的对象。如 Parcel2.Contents c = q.contents();要求在外部类的contents方法中要返回内部类的new对象。
    方式二:内部类实现了外部的一个接口,则可以 interface name = 外部类.get方法返回内部类的对象。都不能直接在外部类中采用new字段去构造对象再访问,可以用封装在外部类的方法中再new内部类后用方法返回。
    方式三:通过.new去创建

使用.this和.new

  1. 要生成对外部类的引用,可以再外部类的名字后紧跟”.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();}
}
  1. 创建某个内部类的对象,使用“.new”。要创建某个类的对象必须使用外部内的对象来创建该内部类的对象。在拥有外部类对象之前是不可能创建内部类对象的,因为内部类会暗暗地连接到引用它的外部类对象上。但是,如果创建的是嵌套类(静态内部类),那么就不需要对外部类对象的引用。
public class DoNew {public class Inner{}public static void main(String [] args){DoNew dn = new DoNew();DoNew.Inner di = dn.new Inner();}
}

内部类与向上转型

当将内部类向上转型为其基类,尤其是转型为一个接口时,内部类就发挥很大作用了。因为内部类——某个借口的实现——能够完全不可见,并且不可用。所以得到得只是指向基类或接口的引用,能够很方便的隐藏实现细节。

在方法和作用域内的内部类

可以在一个方法里面或者在任意的作用域内定义内部类。

  • 实现某个类型的接口,于是可以创建并返回对其的引用。
  • 想创建一个类来辅助解决问题,但不希望这个类是公共可用的。

局部内部类

  1. 在方法的作用域内创建一个完整的类。在方法的作用域外是不能访问的。
  2. 在方法执行完毕,并不意味着局部内部类就不可以使用了。
  3. 可以在同一个子目录的任意类中对局部内部类使用相同的类标识符,这并不会引起命名冲突。

匿名内部类

将返回值的生成与表示这个返回值的类的定义结合在一起。这个类是没有名字的。

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

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/392660.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

leetcode 402. 移掉K位数字(贪心算法)

给定一个以字符串表示的非负整数 num,移除这个数中的 k 位数字,使得剩下的数字最小。 注意: num 的长度小于 10002 且 ≥ k。 num 不会包含任何前导零。 示例 1 : 输入: num “1432219”, k 3 输出: “1219” 解释: 移除掉三个数字 4, 3, 和 2 形成…

javascript 自定义Map

迁移时间:2017年5月25日08:24:19 Author:Marydon 三、自定义Map数据格式 需特别注意的是: js中没有像java中的Map数据格式,js自带的map()方法用于:返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。 map()使…

gif分解合成_如何通过分解和合成使复杂的问题更容易

gif分解合成Discover Functional JavaScript was named one of the best new Functional Programming books by BookAuthority!“发现功能JavaScript”被BookAuthority评为最佳新功能编程书籍之一 ! Our natural way of dealing with complexity is to break it in…

vs2005 新建项目一片空白

最近在研究 workflow fundation ,但是在安装了他的extensions之后,发现VS2005 新建项目一片空白,除开workflow其他的项目模板全部丢失,新建项目对话框中空空如也。查阅资料后发现,可以通过 命令 devenv.exe /InstallVSTemplates 来…

docker导入镜像 liunx_docker扫盲?面试连这都不会就等着挂吧

推荐阅读:java喵:6大面试技能树:JAVA基础JVM算法数据库计算机网络操作系统​zhuanlan.zhihu.com一只Tom猫:都是“Redis惹的祸”,害我差点挂在美团三面,真是“虚惊一场”!​zhuanlan.zhihu.com现…

crontab里shell脚本将top信息写入文件

crontab里shell脚本将top信息写入文件: 注: 1、top -n 1代表执行1次退出(默认top是不退出的),-d 1代表每1秒执行1次 2、crontab里需加/bin/bash # crontab -e */5 * * * * /bin/bash /usr/local/bin/top.sh # vi top.sh #!/bin/ba…

leetcode 1030. 距离顺序排列矩阵单元格(bfs)

给出 R 行 C 列的矩阵&#xff0c;其中的单元格的整数坐标为 (r, c)&#xff0c;满足 0 < r < R 且 0 < c < C。 另外&#xff0c;我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。 返回矩阵中的所有单元格的坐标&#xff0c;并按到 (r0, c0) 的距离从最小到…

Linux iptables:规则原理和基础

什么是iptables&#xff1f; iptables是Linux下功能强大的应用层防火墙工具&#xff0c;但了解其规则原理和基础后&#xff0c;配置起来也非常简单。 什么是Netfilter&#xff1f; 说到iptables必然提到Netfilter&#xff0c;iptables是应用层的&#xff0c;其实质是一个定义规…

太阳系八大行星碰撞的视频_火星的身世:从太阳系的起源说起

大约46亿年前盘状的太阳星云从一大片又冷又暗的气体云中诞生太阳自己并没有任何暴露确切年龄的线索&#xff0c;我们之所以能够知道太阳系的“生日”&#xff0c;是因为迄今从陨石中找到的最古老固体物质&#xff0c;年龄约为45.68亿年。一般认为&#xff0c;太阳系的各个地方是…

refract推导_我们如何利用Refract来利用React式编程的力量

refract推导by Joe McGrath通过乔麦克格拉斯 我们如何利用Refract来利用React式编程的力量 (How we harnessed the power of reactive programming with Refract) Have you ever wondered how open-source libraries built by companies come into existence?您是否想过公司建…

sql server:查詢系統表

---查看所有存储过程或视图的位置 select a.name,a.[type],b.[definition] from sys.all_objects a,sys.sql_modules b where a.is_ms_shipped0 and a.object_id b.object_id and a.[type] in (P,V,AF) order by a.[name] ASC GO--1、查看所有存储过程与函数 exec sp_store…

UDP数据包的大小

问题来源于日志信息&#xff0c;在这里总结一下&#xff0c;后续在补充新的内容。在链路层&#xff0c;由以太网的物理特性决定了数据帧的长度为&#xff08;46&#xff0b;18&#xff09;---&#xff08;1500&#xff0b;18&#xff09;&#xff0c;其中的18是链路层的首部和尾…

博科查看光功率_法拉第旋光器:非互易性旋转光的偏振

法拉第旋光器是利用法拉第效应制作的光学器件&#xff0c;当入射光正向(或反向)进入旋光器时&#xff0c;入射光偏振面会发生旋转。法拉第效应1845年&#xff0c;法拉第发现&#xff1a;当一束平面偏振光通过置于磁场中的磁光介质时&#xff0c;平面偏振光的偏振面就会随着平行…

Object.prototype 原型和原型链

Object.prototype 原型和原型链 原型 Javascript中所有的对象都是Object的实例&#xff0c;并继承Object.prototype的属性和方法&#xff0c;有些属性是隐藏的。换句话说&#xff0c;在对象创建时会存在预定义的属性&#xff0c;其中有一个属性就是原型对象。在函数对象中存在原…

leetcode 406. 根据身高重建队列(贪心算法)

假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对 (h, k) 表示&#xff0c;其中 h 是这个人的身高&#xff0c;k 是应该排在这个人前面且身高大于或等于 h 的人数。 例如&#xff1a;[5,2] 表示前面应该有 2 个身高大于等于 5 的人&#xff0c;而 [5,0] 表示前面不应该…

java和vue2.0

java中的el表达式${对象.属性}和vue中的双向数据绑定{{mode.xx}}感觉有点类似转载于:https://www.cnblogs.com/YangBinChina/p/11180460.html

oh-my-zsh官方教程

https://github.com/robbyrussell/oh-my-zsh/wiki

leetcode 134. 加油站

在一条环路上有 N 个加油站&#xff0c;其中第 i 个加油站有汽油 gas[i] 升。 你有一辆油箱容量无限的的汽车&#xff0c;从第 i 个加油站开往第 i1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发&#xff0c;开始时油箱为空。 如果你可以绕环路行驶一周&#…

ps怎么对比原图快捷键_PS学习之旅:ps如何制作满天星,让你夜晚的天空图片更美...

ps学习之旅&#xff0c;本文介绍关于如何利用ps软件来制作满天星&#xff0c;让你夜晚的天空图片更美&#xff0c;操作很简单哦。1工具/原料Adobe Photoshop CS6软件图片一张2效果展示原图&#xff1a;效果图&#xff1a;3方法/步骤(1)打开PS&#xff0c;选择你想要加星星的一张…

linux程序莫名异常怎么查

内存异常经常导致程序出现莫名其妙的错误&#xff0c;往往很难查证&#xff0c;本文介绍在linux下的各种常见内存异常的查证工具和方法。1 访问空指针/未初始化指针/重复释放内存对于像访问空指针、未初始化指针&#xff08;非法地址&#xff09;&#xff0c;重复释放内存等内存…