corejava学习总结

Corejava学习总结

内容目录

第一章 面向对象编程 ............................................................................................................................................. 2 1.0面向对象概念 ................................................................................................................................................ 2 1.1 类的定义 ....................................................................................................................................................... 2 1.2.类的实例化 .................................................................................................................................................. 3 1.3.类的成员 ........................................................................................................................................................ 3 1.4.类的访问控制 ................................................................................................................................................ 4 1.5.类的三大特性 ................................................................................................................................................ 5 1.6.super和this关键字 ....................................................................................................................................... 7 1.7 关键字static, final和abstract ...................................................................................................................... 8 1.8 抽象类和接口 ............................................................................................................................................... 9 抽象类： ...................................................................................................................................................... 9 接口： ........................................................................................................................................................ 10 接口重写 .................................................................................................................................................... 12 类的修饰符 ........................................................................................................................................................ 14 1.9(1)内部类 ...................................................................................................................................................... 14 1.9.1成员内部类 ........................................................................................................................................ 14 1.9.2静态内部类 ........................................................................................................................................ 15 1.9.3局部内部类 ........................................................................................................................................ 15 1.9.4匿名内部类 ...................................................................................................................................... 16 1.9(2)字符串和包装类 ...................................................................................................................................... 18 字符串 ........................................................................................................................................................ 18 包装类 ........................................................................................................................................................ 19 第二章 集合框架 ................................................................................................................................................... 20 2.1 集合 ............................................................................................................................................................. 20 2.1.1集合的理解 ........................................................................................................................................ 20 2.1.2为什么要使用集合 ............................................................................................................................ 20 2.1.3 Collection 接口和Collections类 ..................................................................................................... 20 2.1.4 List ..................................................................................................................................................... 20 LinkedList: .................................................................................................................................................. 21 2.1.5 Set ...................................................................................................................................................... 22 2.1.6 Map .................................................................................................................................................... 23 2.1.7 toString(),equals(),hashCode() .................................................................................................................. 25 第四章 泛型 ........................................................................................................................................................... 26 4.1 为什么要使用泛型 ..................................................................................................................................... 26 4.2泛型的使用 .................................................................................................................................................. 27 第五章 正则表达式 ............................................................................................................................................... 28 5.1 正则表达式的应用 ..................................................................................................................................... 28 第六章 异常 ........................................................................................................................................................... 29 6.1 Exception ...................................................................................................................................................... 29 6.2自定义异常 .................................................................................................................................................. 30

6.4 printStackTrace()和printStackTrace(PrintWriter out) ................................................................................. 31 6.5 异常链 ......................................................................................................................................................... 32 第七章 多线程 ....................................................................................................................................................... 32 6.1 进程与线程的区别 ..................................................................................................................................... 32 6.2 同步与异步 ................................................................................................................................................. 32 6.3 并发与并行 ................................................................................................................................................. 32 6.4 java中的线程 .............................................................................................................................................. 32 6.5 Thead与Runnable接口实现线程的区别与联系 ...................................................................................... 33 区别: ................................................................................................................................................................... 33 6.6 后台线程 ..................................................................................................................................................... 36 6.7 线程的让步 ................................................................................................................................................. 36 6.8 强制线程运行 ............................................................................................................................................. 37 6.9线程的同步,异步和死锁 ............................................................................................................................. 37 第八章 IO操作 ...................................................................................................................................................... 42 8.1 文件 ............................................................................................................................................................. 42 8.2 字节流 ......................................................................................................................................................... 42 8.3 字符流 ......................................................................................................................................................... 46 8.4 序列化与反序列化 ..................................................................................................................................... 46 第九章 网络编程 ................................................................................................................................................... 48 第十章 反射 ........................................................................................................................................................... 49 10.1反射的理解 ................................................................................................................................................ 49 10.2 反射的作用 ............................................................................................................................................... 49 10.3 反射的使用 ............................................................................................................................................... 49 第十一章 注解(Annotation) ................................................................................................................................. 55 11.1 注解的概念 ............................................................................................................................................... 55 11.2 注解的使用 ............................................................................................................................................... 55 11.3 定义注解 ................................................................................................................................................... 55 11.4元注解 ........................................................................................................................................................ 55

第一章 面向对象编程

1.面向对象概念

什么叫对象？

万物皆对象，一个人你可以把它看作是一个对象。大家找女朋友或男朋友的时候，那个女朋友或男朋友就可以看作是你的对象。

什么是类？

类是对象抽象，是从一类对象中抽象出来的共同点。

类和对象的关系？

类是对象的模板，类是对象的抽象，对象是类的实例。

使用面向对象的思维编程有哪些好处？

1. 类的定义

怎样去定义一个类？

[modifier] class classname{ }

一个类能够定义为public，package private(默认) 的。

//类体

1..类的实例化

怎样去实例化一个类

类名 引用名 = new 类名(); 示例：

public class Person{}

Person p = new Person();//类的实例化

类实例化的三个步骤：

1.为对象分配内存空间。 2.为成员属性赋值。 3.调用构造方法。

1..类的成员

示例：

public class Person｛

private int height;//属性 private int weight; private int age; private String name;

public void sleep(){//类和行为 }

class Koo{//内部类

int i = 1; public void test(){

｝

}

}

属性：描述类的特征。

修饰属性的修饰符和方法所能用的修饰符是一样的。

用static 修饰的是静态变量，又称为类变量。在所有的类的实例之间是共享的。 用static final修饰的成员属性称为常量。常量一经初始化就不能被修改。 常量有两种初始化方式： 1.定义时直接初始化。

2.定义之后，在静态代码块中初始化。

用final修饰的成员属性称为最终变量，它初始化后就不能再更改了。 它有两种初始化的方式： 1.定义时直接初始化。 2.在构造方法中初始化。

不是用static final,static修饰的成员属性，你如果在定义它的时候，没有给它初始化，系统会以它们相应类型的默认值来给它们初始化。如:int 会初始化0,boolean 为 false,引用类型会初始化为null 等。

private int height;//属性 private int weight;//属性 private int age;//属性 private String name;//属性 这些描述一个人的基本特性。 属性有三种赋值方式：

1.定义时就赋值 2.通过构造方法赋值 3.在成员方法中赋值

方法：类的行为

public void sleep(){//类和行为 }

可以用来修饰方法的修饰符有：static,final,static final,public, private ,protected,abstract。

用static修饰的方法是静态方法，不属于任何对象，只属于类本身，在所有对象之间是共享的。在访问的时候，使用 类名.方法名 的形式去调用。

内部类：在类内部定义的类。

class Koo{//内部类 }

int i = 1; public void test(){ }

1.类成员的访问控制

修饰符 Public protect default(默认的) private

类内 √ √ √ √ 包内 √ √ √ × 子类 √ √ × × 包外 √ × × × 1..类的三大特性

封装：就是以一种固有的形式把类提供给外部使用的方式。让外部只能使用类的实例来访问类的内部

行为和属性。封装提高了数据的安全性，使用者不必关心它内部的细节。

封装就是把一类相同的特征和行为合并为一种数据类型，这种数据类型就称为类。

继承：一个类继承另一个类，继承的类称为子类，被继承的类称为父类。一个类没有明确的声明它的父类，则默认继承java.lang.Object。Object类是所有java类的直接或 间接父类。Object类中所有方法者将被它的子类继承。

java中只支持单继承，一个父类可以有多个子类，一个子类只能有一个父类。

子类在实例化的时候，会自动调用父类的构造方法，使用super()或super(args) 来调用父类的构造方法，它必须放在子类构造方法中的第一行.如子类中没有super方 法，系统会自动加上super方法。

子类不能继承父类的私有成员，父类可以提供一个让子类能够访问它里面私有成员的方法。还可以通过父类的内部类来访问它的父类的私有成员。

子类中定义了一个与父类的私有方法同名的实例方法，这个方法和父类的同名私有方法不是覆盖的关系，它们之间没有任何联系，子类的这个方法是一个新方法。一般在编程中尽量不要定义这样的方法，因为这样会降低程序的可读性。

子类中重写了一个与父类同名的类方法(静态方法)，这种情况也不属于方法的覆盖，而只是方法的隐藏。

一个要引用父类的属性，必须用super.父类的属性名来访问。而不能直接用属性名来访问，不像方法的覆盖一样，子类没有就会到父类去找。因为属性在类实例化的时候就会分配空间，父类的属性和子类的同名属性它会配不同的内存空间，你用同一个属性名去访问，它默认你访问的是子类的属性，这可以理解为就近原则吧。

子类想调用父类的方法，可以用super.父类的方法名。

class Animal{ }

class Cat entens Animal{//Cat继承了Animal类//Cat是Animal的子类，Animal //是cat的父类

public Cat(){ }

public void sleep(){}//覆盖了Aimal中的sleep方法 public void eat(){}//覆盖了Animal中的eat方法

super();//这个方法必须写在子类构造方法的第一行，如果不写，//系统会自动加上

public Animal(){} public void sleep(){} public void eat(){}

}

多态：一个类的多种形态，主要体现在父类与子类上。多态产生的前提是必须有继承关系存在。

多态主要体现在方法调用上，并不是所有东西都可以以多态的形式出现的。

私有方法是不能实现多态调用的，类方法(静态方法)是不能实现多态调用的。私有属性不能多态调用。

class Animal{ }

class Cat extends Animal{ }

class Dog extends Animal{ }

Animal animal1 = new Cat();//多态

Animal animal2 = new Dog();//多态

animal1.test();//Cat sleep!//访问的是Cat类中的sleep方法 animal2.test();//Dog sleep!//访问的是Dog类中的sleep方法

public void sleep(){System.out.println(\public void sleep(){System.out.println(\public void sleep(){System.out.println(\

1.6.super和this关键字

super:

使用super关键可以访问父类中的实例成员，在子类中调用父类中的同名方法时就可以用super.父类中的方法名

使用super()方法调用父类的构造方法，super()方法必须放在子类构造方法的第一行。 class Animal{ }

class Cat entens Animal{//Cat继承了Animal类//Cat是Animal的子类，Animal 是cat的父类

public Cat(){super();//必须写在子类构造方法的第一行 }

public Animal(){} public void sleep(){} public void eat(){}

}

public void sleep(){}//覆盖了Aimal中的sleep方法 public void eat(){

super.eat();//调用父类的eat()方法

}//覆盖了Animal中的eat方法

this:表示一个类的当前实例，this不能在类的静态方法中使用。

为什么要用this关键呢？

假如在一个类的方法中调用这个类的成员属性，且这个方法中有与成员属性名相同的局部变量，为了区分成员属性与局部变量，这个时候你就要用到this关键字。this.属性名代表引用当前实例的属性。

一个类有多个构造方法，怎样在一个构造方法去调用另外一个构造方法？

我们可以使用this(参数列表)的形式来调用，且this（）调用必须放在构造方法的第一行。 public class Person{ }

private int age; public Person(){ }

public Person(int age){ }

this.age = age;//使用this来区分局部变量和成员变量 this(12);//调用有参构造方法，this指代当前类的实例

1.7 关键字static, final和abstract

static: 静态的，java中用它来修饰属性，方法，代码块，或者内部类

修饰属性(类变量)：属于整个类，不属于类的实例对象，所有类之间共享这个变量。

静态变量可以直接用类名来调用，也可以用类的实例变量来调用(这种做法不 推荐).

静态变量，实例变量，局部变量的区别：

1.静态变量也叫类变量，类加载时就开始初始化，类卸载时消亡，存放在代码 区。 2.实例变量，有了对象之后才有，有初始值，存放在堆区，随对象而存在。 3.局部变量，只在定义它的代码块内有效，存放在栈区。

修饰方法：静态方法。在静态方法中不能访问非静态属性和非静态方法。

特点：

1.静态方法可以被覆盖，但没有多态。所以，java jvm对于静态方法的选择，看编译时类型，而不是运行时类型。

2.父类静态的方法只能由子类静态的方法覆盖，非静态的也只能由非静态的覆盖。 3.静态方法中不能使用this关键字，

静态变量或静态方法的调用应遵守的规则：

静态的不能调用非静态的。

静态，只是类的概念，不存在对象的概念，

静态代码块：在一个类被实例化的时候它只被调用一次。

package com.summary.staticandinnerclass; public class StaticKeyDemo1 { }

static{//静态代码块 System.out.println(\); }

public StaticKeyDemo1(){ }

public static void main(String[] args) { }

StaticKeyDemo1 skd1 = new StaticKeyDemo1(); StaticKeyDemo1 skd2 = new StaticKeyDemo1(); StaticKeyDemo1 skd3 = new StaticKeyDemo1();

System.out.println(\);

执行结果：

static block!

StaticKeyDemo1.StaticKeyDemo1() StaticKeyDemo1.StaticKeyDemo1() StaticKeyDemo1.StaticKeyDemo1()

final: 最终的，

final用来修饰一个类,方法,属性或局部变量 ,用它修饰的类，是不能被继承的，用它修饰的方法是不能被覆盖的，用它修饰的变量必须在定义的时候初始化或者在构造方法中初始化，且初始化后，它的值是不能被改变的。其它地方初始化都是错误的。

final类中的所有方法默认是final的。

static final 或者 final static java中常量的定义符号：

示例：private static final int AGE = 23;//常量的变量名建议全部大写 常量有两种初始化的方式：

方法一：在定义时初始化. 方法二：在静态代码块中初始化. 示例：

package com.summary.staticandinnerclass; public class StaticDemo3 {

static final int B; static{

B = 10;//初始化方法二 }

static final int A = 0;//初始化方法一 }

常量一经定义且初始化后它的值就不能被修改了。

abstract:定义抽象类或抽象方法时的关键字,用它修饰的类是抽象类或方法.

1. 抽象类和接口

抽象类：

用abstract 修饰的类,例如：

public abstract class Animal{}

抽象类不能被实例化，只有实现了它里面的抽象方法的子类才能被实例化，如果这个子类没实现它里面的抽象方法，也要被定义为抽象类。

一个类里面有抽象方法，那么它就一定要定义为抽象类。一个类是抽象类，那它里面的方法不一定都是抽象方法。

class Dog extends Animal{//Dog类实现了Animal类里面的所有方法

abstract class Dog extends Animal{//类没有实现Animal里面的所有方法， //所以要被定义为抽象类,不可以被实例化 }

@Override

public void eat() { }

抽象方法没有方法体，以分号结尾。

示例：

abstract class Animal{//抽象类

public abstract void sleep();//抽象方法 public abstract void eat();//抽象方法 }

}

@Override

public void eat() { }

@Override

public void sleep() { }

public static void main(String[] args){ Dog dog = new Dog();//可以被实例化 }

一个类实现了一个接口的里面的部分方法，那么这个类要定义为抽象类。

示例：

interfaceB{ void test(); }

abstract class A implements B{} class C extends A{ }

public void test() {}

一个抽象类里面有静态方法和静态属性，你可以在其它的类中用类名直接去调用它们。

接口：

在java语言中接口和类是一个引用类型，它的成员只能是常量，没有方法体的方法，以及内部类型。接口不能被实例化，只能够被一个类去实现或者继承其它接口。

定义一个接口类似于创建一个新的类：

public interface OperateCar {

int A = 10; //声明常量

int turn(Direction direction, // An enum with values RIGHT, LEFT

double radius, double startSpeed, double endSpeed);//接口中的方法都没有方法体

int changeLanes(Direction direction, double startSpeed, double endSpeed); int signalTurn(Direction direction, boolean signalOn); int getRadarFront(double distanceToCar, double speedOfCar); int getRadarRear(double distanceToCar, double speedOfCar); class A{}//接口中可以定义一个内部类 }

接口里面定义的方法没有方法体，且要以分号结尾。

使用接口，你能够写一个类去实现这个接口。当一个类实现了这个接口里面的所声明的方法，它就能够被实

例化。

public class OperateBMW760i implements OperateCar { int signalTurn(Direction direction, boolean signalOn) { }

int changeLanes(Direction direction, double startSpeed, double endSpeed){

}

int getRadarFront(double distanceToCar, double speedOfCar){

}

int getRadarRear(double distanceToCar, double speedOfCar){

} }

一个接口访问修饰符是public，表示这个接口能够被任何包里面的任何类去使用，假如接口没有访问修饰

符(default)，这个接口只能在与这个接口在同一个包下面的类去使用。接口的前面还可以加上abstract关键字，但是它必须放在interface这个定义接口的关键字前面。

例如： public interface USB{};

public abstract interface USB{};

接口是一种特殊的抽象类,接口中所有的方法都是抽象方法,一个类可以实现多个接口,接口中的所有属性都会自动声明为public final static，接口中的方法前面的都会隐含地加上public abstract，所以public abstract可以省略，且方法没有方法体。接口与接口之间可以多重继承，接口中没有构造方法,当我们用类去实现接口时，如果不希望实现类是抽象类的话，那么就要实现接口中定义的所有的方法,一个类在继承另外一个类的同时，还可以实现多个接口，多个接口之间用逗号隔开。

public ,static 和final这些修饰符，系统都会隐含地加上，所以在接口中定义属性和方法时，这

几个修饰符可以省略。

public interface USB { };

public static class Foo{//接口中定义内部类 public void test(){ };

Foo foo = new Foo();

System.out.println(\中国人！\ ); }

class UsbMouse implements USB{ }

interface Mouse{}

abstract interface A{//在接口前面加abstract，是正确的 void test(); };

class C implements A{ }

@Override

public void test() {

System.out.println(\); }

public void test(){

UsbMouse um = new UsbMouse();

um.foo.test();//调用USB接口中的内部类方法

}

}

public static void main(String[] args) { }

C c = new C(); c.test();

UsbMouse um = new UsbMouse(); um.test();

输出结果为：

class C implements A 中国人！

接口重写

假如你原来已经写好的一个接口，因为现在有新的功能需求，需要在这个接口中新增一个方法，你应该怎么办？是否在这个接口里把这个方法直接加进去就可以了， 这个方法是可以，但不提倡这么做，因为一个接口写好以后，可能有很多类在使用在这个接口，如果把方法加到这个接口中，那么那些实现这个接口的类，就必须把这个接口重新实现，这对于一些很大的应用是一件非常麻烦的事情，所以我们可以把这个方法添加到一个新得接口中，让这个新的接口继承原来的接口，这样原来那些使用这个旧接口的应用就有了选择的余地，它可以选择升级到这个新得接口，也可以保持原来的应用不变。 Public interface USB{ void show();} public interface NewUSB extends USB{ void getType();}

接口是一种标准，是来规范我们的应用的。例如电脑上的usb接口的键盘和鼠标，它们必须实现了USB接口标准才能够被电脑上的USB接口所接纳。

接口的好处： 就拿USB接口来说，对于我们这些使用USB接口键盘和鼠标的用户来说，USB接口

的键盘和鼠标为什么插到机箱上的USB插口(接口)上就能操作电脑，这内部的细节我们没有必要去了解，这些是那些产家去实现的，我们只要去使用它就可以。以后它内部的实现有什么变化了，对上层的接口及我们用户对它的使用没有什么影响。

}

interface Type extends USB{ }

USBServiceProvider implements USB{//usb接口服务的提供者 public void type(){ }

class Mouse implements Type{//usb接口服务的使用者 public void type() {}

public void show() {} }

void show();

换言之，接口的使用让服务的使用者和服务的提供者(服务实现者)分离开来.

给编程带来的好处：

高内聚低偶合。

示例：

interface USB{ }

public class Mouse implements USB{//须要实现接口里面定义的所有方法 }

public void type(){ }

void type(); //public final static

接口与接口之间的多继承：

interface USB{ }

void type();

Mouse 和 USBServiceProvider唯一出入口就是USB这个接口，是它们交流信息的桥梁。

USB这个接口把实现了它们逻辑上的关联。把USB接口服务的实现者（USBServiceProvider）和使 用者( Mouse)分离开来。所以Mouse只要关心USB接口这个标准就可以了，USB服务的实现者内部具体是怎么做的，就不是它所关心的事情了。

接口与抽象类之间的区别：

1.接口里面的所有方法都是抽象方法，而抽象类里面的方法并不一定全都是 抽象方法。

2.假如一个抽象类里面的方法全是抽象方法，应该用接口来代替它。

3.假如一个类只实现了一个接口里面的部分方法，那么这个类要定义为抽象类。 4.接口里面的成员变量者常量，而抽象类里面的成员变量并不一定都是常量。

5.接口没有构造方法，抽象类在子类（实现了里面的抽象成员）在实例化的时候，一定会调用它的父类的构造方法。

类的修饰符

在类(不包括内部类)的前面可以有的修饰符：

modifier for the class A; only public, abstract & final are permitted 类前面的修饰符可以是public,abstract,final,以及default(默认的，就是类前面没写类的访问修饰符的情况)

Abstract,final是不能一起使用的。

因为final修饰的类是不能被继承的，而abstract修饰的类是抽象类，是可以被其它类继承的。所以它们两个在一起使用，就自相矛盾了。

1.9(1)内部类

定义在类内部的类。 使用内部类有什么好处呢？

1.可以让一个类独享一个类所有成员和方法，而不被其它类使用。 2.能够访问外部类中的私有成员。 3.增加封装性。

4.更好的代码可读性和维护性。

内部类分为以下四种：

1.9.1成员内部类

类名前面修饰符可以private,public ,default,protected,abstract,final。abstract前面几种可以和abstract一起使用,final是不行的。

定义在类的内部，没有用static关键字修饰的 public class A{ int a = 10;

class B{}//非静态内部}

在外部类的里面实例化的方式：

this.new B(); //this代表当前A的实例

在外部类的外面创建内部类的实例的方式：

(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.装箱与拆箱

装箱：

本文来源：https://www.bwwdw.com/article/fwlv.html