Thinking in java个人笔记
Ø 再谈内部类:(1)内部类就是在外部类里面声明类(class outer{classinner{…}}),外部类可以指定一个方法to指向内部类(public inner to(String s){return new inner(s)}),如果想要在静态方法之外的任何位置创建某个内部类对象,那么必须像main方法那样指明类型:outer.inner;(2)内部类会自动拥有外部类所有成员的访问权限P192,内部类想要生成外部类对象(在内部类的方法中return outer.this),创建某个内部类对象:outer ou=new outer();outer.inner in=ou.new inner();||outer.innerin=ou.inner();(产生内部类的引用),在创建外部类对象之前是不可能创建内部类对象的,但是如果创建的是嵌套类(静态内部类)就不需要依赖于外部类对象的引用,可以在外部类定义一个方法返回接口类型的实现接口的类(public interfacetype contents(){return new 接口实现类})为了更好的隐藏实现细节
Ø 再谈内部类:局部内部类(可以在任何位置定义->实现接口,解决复杂问题但是又不希望这个类是公共可用的)例如(publiccalss p{private void test(int a){if(a==1){class b{private String i;publicString haha(){return i;}}}}})这个内部类在if的作用域之内
Ø 再谈内部类:匿名内部类:实现接口或者扩展类
abstract class Base{
public Base(inti) {
System.out.print("Base"+i);
}
public abstract voidfun();
}
public class Anner {
public static BasegetBase(int a) {
returnnew Base(a) {
publicvoid fun() {
System.out.println("fun");
}
}
}
}
匿名内部类实现接口:
interface content{
void play();
}
public class Anner{
public content getContent() {
return new content() {
private int i=10;
public void play() {
System.out.println(i);
}
};
}
public static void main(String[]args) {
Anner a=new Anner();
content t=a.getContent();
t.play();
}
}
Ø 再谈内部类:嵌套内部类(如何不需要内部类对象与外部类对象有联系)将内部类声明为static
interface content{
void play();
}
public class Anner{
public static classContent implements content{
public void play(){
System.out.println("haha");
}
}
public static ContentgetContent() {
return newContent();
}
public static voidmain(String []args) {
Content a=getContent();
a.play();
}
}
Ø 接口内部的类:在接口中定义一个类,使得被某个接口的所有不同实现所共用
interface content{
void play();
class gonten implementscontent{
private int i;
public gonten(inta) {
this.i=a;
}
public void play(){
System.out.print(i);
}
public static voidmain(String[] args) {
gonten a=newgonten(10);
a.play();
}
}
}
Ø 内部类的魅力所在:每个内部类都可以独立的继承一个(接口的)实现,所以无论外部类是否继承了某个(接口的)实现,对于内部类都是没有影响的。
Ø 内部类的继承:
class outer{
class inner{
}
}
public class Alpha extends outer.inner{
Alpha(outer i){
i.super();
}
public static voidmain(String[] args) {
outer o=newouter();
Alpha a=newAlpha(o);
}
}
Ø 闭包:闭包是一个可以调用的对象,它记录了一些信息,而这些信息来自于创建它的作用域,可见内部类就是一个闭包,它不仅包含了外部类的信息,还包含了外部类的一个引用,在此作用域内,内部类有权操作所有成员,包括private成员。
Ø 内部类能否被覆盖问题:外部类再被继承的时候,复写内部类,会产生两个独立的内部类,因此内部类不会被覆盖。
Ø 内部类标示符:编译完成class后,内部类的命名形式为外部类名+$+内部类名