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后，内部类的命名形式为外部类名+$+内部类名