(new A()).new B();
在内部类里访问外部类的成员：
A.this.a;
private abstract class A{}//这个类前面的修饰符private abstract有什么 含义？
加上private ，是让这个内部类不能在外部类的外面被访问，只能在这个类的 内部使用，这种方式可以完全阻止任何依赖于类型的编码，并完全隐藏实现的细节。 加上abstract，是让这个内部类不能被实例化，只能让实现了它的子类去实 例化。 private abstract一起使用，是为了让这个类在外部类的外面不能不使用，同时在类的内部不能被实例化。
1.9.2静态内部类
用static 关键字修饰的内部类。
静态内部类的修饰符可以是：private， protected， public，protected ，abstract,static,final static。abstract不能和final，以及和static final一起使用。 public class A{static class B{}//静态内部类} 静态内部类的实例方式：
new A.B();//因为是静态的，所以不要new外部类的实例
静态内部类只能访问外部类的静态成员。
1.9.3局部内部类
像局部变量一样，不能申明为public,protected,private和static.它的使用域只在 定义它的方法内可以修饰内部类的修饰符有:final,abstract, final和abstract不能一起使用。
只能访问它所在方法里面用final修饰的变量，非final修饰的变量不能被访问，会报错误。 public class A{
部。
public void a(){
int w = 10; final int f = 10; class C{//局部内部类
//int c = w;//错误,不能访问非final类型的变量 int c = f;//正确 }
class B{}//局部内部类
abstract class C{}//可以用abstract修饰
final class D{}//可以用final 修饰,里面的成员不是final类型的
}
}
1.9.4匿名内部类
没有class关键字，没有extends，implements关键字，没有构造方法， 隐藏的继承一个父类或实现一个接口。
class B{ public test(){ }
Comparator com=new Comparator(){//用匿名内部类实现java.util.Comparator比较器 @Override };
public int compare(Object o1, Object o2) { }
return 0;
匿名内部类特殊的局部内部类。
}
内部类，前面可以用private修饰，局部内部类不能用private 来修饰， 一个类的内部可以定义接口，一个内部类(包括局部内部类)可以用final,abstract来修饰，局部内部类不能定义为静态的。
示例：
import com.summary.staticandinnerclass.StaticDemo1.Goo; //private class StaticDemo1 {//修飾符不能是private public class StaticDemo1 {
public static void main(String[] args) { }
Koo koo = new StaticDemo1.Koo();//靜態內部的類的初始化方式 Goo goo = new StaticDemo1().new Goo();//非靜態內部類初始化方式 A a = new A(){//接口 的实现方式 public void test() { };
System.out.println(\ }
public static void a(){
static int a = 0;//局部变量不能定义为静态的
final class Foo{////正确的 , 它里面的成員不是final的，只有在成員前面加上final修
// //
飾符 // // // //// // // // // // // // // //
}
}
int a = 9; final int b = 10; public void test(){ }
b =12;//错误的
a = 11;//正确的
System.out.println(\ System.out.println(\
Foo foo = new Foo(); foo.test();
static class Foo{//错误的， 不存在局部靜態內部類 }
abstract class Foo{//正确的 public abstract void test(); }
class Joo extends Foo{ }
Joo joo = new Joo(); joo.test();
public void test() {
System.out.println(\); }
private static class Koo{//内部类，前面可以用private修饰，局部内部类不能用private 来
public void test(){ }
public static void say(){ }
System.out.println(\); System.out.println(\);
修饰
}
class Goo{//非靜態內部類里面不能有靜態變量和方法
public static int a = 9;//錯誤
public void test(){ }
public static void say(){//錯誤 System.out.println(\ }
System.out.println(\);
//
// // //
}
}
class Doo extends Goo{ }
public void test(){ }
System.out.println(\);
private class Hoo{//它的前面的修飾可以是private，外部類前面的修飾符不能是private }
interface A{//在一个类的内部可以定义接口 void test(); }
A a = new A(){
@Override
public void test() {
System.out.println(\);
}};
Goo goo = new Goo(){ };
public void test(){ }
System.out.println(\);
class TestInnerClass1{
public void test(){
StaticDemo1.Goo goo = new StaticDemo1().new Goo();//在一個內部類的外部類外面創
建內部類的實例 Goo doo = new StaticDemo1().new Doo(); }
}
1.9(2)字符串和包装类
字符串
String:定长字符串，是final类型的，不可被继承。(不变模式)
String s = “abc”和 String s = new String(“abc”);的区别：
第一种方式：字符串是放在字符串常量池中,每一次都是引用的同一个字符串。
第二种方式：字符串是存放堆区，每次用这种方式创建字符串对象，就会在堆区产生 一个新的对
象。
}
//String 是final类型，不能被继承
public static void main(String[] args) {
String s1 = \;
String s2 = \;//非实例化出来的字符串是放在常量池中的，s1和s2引用的是同一个地址 System.out.println(s1 == s2);//true//s1,s2引用的是同一个字符串地址 System.out.println(s1.equals(s2));//
String s3 = new String(\); String s4 = new String(\);
System.out.println(s3 == s4);////显然内容相同，但是地址不同 System.out.println(s3.equals(s4));////比较的是内容，内容相同 String s5 = s3;//指向s3所指向的字符串,地址一样 System.out.println(s5 == s3);////地址相同
示例：
public class StringDemo1 {
System.out.println(s5.equals(s3));////内容一样 }
在用String做字符串拼接时，由于String是final类型的，值是不能被改变，每拼接一次，可能都
会产生一个新的字符串，这样就造成了内存资源的浪费，所以在做字符串拼接操作时，尽量不使用String类型来做，而使用StringBuffer 和 StringBuilder来做。
和 StringBuilder
StringBuffer 和StringBuilder是可变长的字符串。 StringBuffer 和stringBuilder的比较
线程安全 执行效率 StringBuffer 线程安全 较高 StringBuilder 非线程安全 高
包装类
中八种基本类型都有它们各自的包装类型。 Integer：int型的包装类。
4.装箱与拆箱
装箱：
百度搜索“77cn”或“免费范文网”即可找到本站免费阅读全部范文。收藏本站方便下次阅读，免费范文网，提供经典小说综合文库corejava学习总结(4)在线全文阅读。
相关推荐：