java实战篇：第三篇，面向对象

一、什么是面向对象

面向对象的思想：万物皆对象。一个iphone13可以理解为一个对象，它具有电池、处理器、存储卡等属性，具有上网、计算、记录等功能。对象其实是一种思想。
对象一定是一个具体的、确定的物体。

二、类

iphone、华为、OPPO，vivo等手机，这些都是手机，可以看做手机类。封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。

类是一个抽象的概念，是具有相同属性和方法（行为）的对象的集合。

定义类

定义一个类，主要有三个步骤：

1、定义类名，用于区分不同的类。如下代码中 public class 后面跟的就是类名。class是声明类的关键字，类名后面跟上大括号，大括号里面就是类的一些信息。public 为权限修饰符。

2、编写类的属性。对象有什么，需要通过属性来表示。属性的定义是写在类名后面的大括号里，在定义属性时，要明确属性的类型。在一个类当中可以写一个或多个属性。当然也可以不定义属性。

3、编写类的方法。方法也是写在大括号里面。可以定义一个方法或多个方法，当然也可以不定义方法。

public class 类名 {
    //定义属性部分（成员变量）
    属性1的类型 属性1;
    属性2的类型 属性2;
    ...
    //定义方法部分
    方法1
    方法2
    ...
}

this

this 关键字代表当前对象。使用 this.属性 操作当前对象的属性，this.方法 调用当前对象的方法。

用 private 修饰的属性，必须定义 getter 和 setter 方法才可以访问到 (Eclipse 和 IDEA 等 IDE 都有自动生成 getter 和 setter 方法的功能）。

public void setAge(int age) {
  this.age = age;
}
public int getAge() {
  return age;
}

创建好了 getter 和 setter 方法后，我们发现方法中参数名和属性名一样。

当成员变量和局部变量之间发生冲突时，在属性名前面添加了 this 关键字。 此时就代表将一个参数的值赋给当前对象的属性。同理 this 关键字可以调用当前对象的方法，同学们自行验证一下吧。
一个类可以包含以下类型变量：

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为 static 类型。

下面创建一个类

public class People{
// 属性(成员变量)有什么
    double height; //身高
    int age; //年龄
    int sex;//性别

//方法 干什么
    void cry(){
        System.out.println("哭吧");
    }

    void laugh(){
        System.out.println("我在笑");
    }

    void printBaseMes(){
        System.out.println("我的身高是"+height+"cm");

        System.out.println("我的年龄是"+age+"岁");

        if(this.sex==0)
            System.out.println("我是男性！");
        else
            System.out.println("我是女性");
    }
}

一个类可以包含以下类型变量：
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为 static 类型。

成员变量

刚刚我们引入了成员变量这个概念，那什么是成员变量呢？成员变量就是指的对象的属性，是在类中定义，来描述对象的特性。还有一种变量叫局部变量，它是由类的方法定义，在方法中临时保存数据

在使用时注意，成员变量可以被本类的所有方法所使用，同时可以被与本类有关的其他类所使用。而局部变量只能在当前的方法中使用。

作用域

在这里我们要讲到一个关于作用域的知识了。作用域可以简单地理解为变量的生存期或者作用范围，也就是变量从定义开始到什么时候消亡。

1局部变量的作用域仅限于定义它的方法内。而成员变量的作用域在整个类内部都是可见的。
2同时在相同的方法中，不能有同名的局部变量；在不同的方法中，可以有同名的局部变量。
3成员变量和局部变量同名时，局部变量具有更高的优先级。 大家可以编写代码验证一下。

创建对象

创建对象就是实例化类

People LiLei = new People();

创建对象
定义类的时候不会为类开辟内存空间，但是一旦创建了对象，系统就会在内存中为对象开辟一块空间，用来存放对象的属性值和方法。

//定义一个类
class People{  
// 属性(成员变量)有什么
    double height; //身高
    int age; //年龄
    int sex;//性别

//方法 干什么
    void cry(){
        System.out.println("哭吧");
    }

    void laugh(){
        System.out.println("我在笑");
    }

    void printBaseMes(){
        System.out.println("我的身高是"+height+"cm");

        System.out.println("我的年龄是"+age+"岁");

        if(this.sex==0)
            System.out.println("我是男性！");
        else
            System.out.println("我是女性");
    }
}

//创建对象，即实例化类
public class NewObject{
    public static void main(String[] args){
        //实例化类
        People LiLei = new People();  //实例化LiLei
        LiLei.height = 170;
        LiLei.age = 20;
        LiLei.sex = 1;
        LiLei.printBaseMes();
    }
}

构造方法

在面向对象中有一个非常重要的知识点，就是构造方法。每个类都有构造方法，在创建该类的对象的时候他们将被调用，如果没有定义构造方法，Java 编译器会提供一个默认构造方法。 创建一个对象的时候，至少调用一个构造方法。比如在新建一个对象 new Object()，括号中没有任何参数，代表调用一个无参构造方法（默认构造方法就是一个无参构造方法）。构造方法的名称必须与类名相同，一个类可以定义多个构造方法。

构造方法的名称与类名相同，且没有返回值。它的语法格式如下：

public class People{
    //无参构造方法
    public People(){

    }
    //有一个参数的构造方法
    public People(int age){

    }
}

一个具体的构造方法的例子

public class People {
//属性（成员变量）有什么
    double height;     //身高
    int age;           //年龄
    int sex;       //性别，0为男性，非0为女性

    //构造方法，初始化了所有属性
    public People(double h, int a, int s){
        height = h;
        age = a;
        sex = s;
    }
}

//创建对象，调用我们自己定义的有参构造方法
People XiaoMing = new People(168, 21, 1);

上面的例子中通过 new 关键字将类实例化成对象，而 new 后面跟的就是构造方法。于是可以知道 new + 构造方法 可以创建一个新的对象。

2、如果在定义类的时候没有写构造方法，系统会默认生成一个无参构造方法，这个构造方法什么也不会做。

3、当有指定的构造方法时，系统都不会再添加无参构造方法了。

4、构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。

问题：构造方法和类的区别是什么呢？

类和对象之间有什么关系

在上面的讲解中大家应该有些了解了。类就是对象的抽象（或者模板），对象就是类的具体（或者实例）。比如手机是一个抽象的概念，它代表着类。而一部 iPhone 6 便是手机具象化处理的实体，也就是一个对象。

三、静态成员和静态方法

静态成员
Java 中被static修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。

public class StaticTest{
    public static String string="shiyanlou";
    public static void main(String[] args){
        //静态成员不需要实例化 直接就可以访问
        System.out.println(StaticTest.string);
        //如果不加static关键字 需要这样访问
        StaticTest staticTest=new StaticTest();
        System.out.println(staticTest.string);
        //如果加上static关键字，上面的两种方法都可以使用
    }
}

静态方法
被static修饰的方法是静态方法，静态方法不依赖于对象，不需要将类实例化便可以调用，由于不实例化也可以调用，所以不能有this，也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。

四、权限修饰符

代码中经常用到 private 和 public 修饰符，权限修饰符可以用来修饰属性和方法的访问范围。

如图所示，代表了不同的访问修饰符的访问范围，比如 private 修饰的属性或者方法，只能在当前类中访问或者使用。默认 是什么修饰符都不加，默认在当前类中和同一包下都可以访问和使用。protected 修饰的属性或者方法，对同一包内的类和所有子类可见。public 修饰的属性或者方法，对所有类可见。

我们可以举一个例子，比如 money，如果我们用 private 修饰代表着这是私有的，只能我自己可以使用。如果是 protected 代表着我可以使用，和我有关系的人，比如儿子也可以用。如果是 public 就代表了所有人都可以使用。

五、supper

super 关键字在子类内部使用，代表父类对象。

1访问父类的属性super.属性名。
2访问父类的方法 super.bark()。
3子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()。

六、final

final
final 关键字可以修饰类、方法、属性和变量

1final 修饰类，则该类不允许被继承，为最终类
2final 修饰方法，则该方法不允许被覆盖（重写）
3final 修饰属性：则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）
4final 修饰变量，则该变量的值只能赋一次值，即常量

//静态常量
public final static String SHI_YAN_LOU="shiyanlou";

七、重载与重写

方法重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。方法重载一般用于创建一组任务相似但是参数不同的方法。

方法重载是在针对一个类的。

public class Test {
    void f(int i) {
        System.out.println("i=" + i);
    }

    void f(float f) {
        System.out.println("f=" + f);
    }

    void f(String s) {
        System.out.println("s=" + s);
    }

    void f(String s1, String s2){
        System.out.println("s1+s2="+(s1+s2));
    }

    void f(String s, int i){
        System.out.println("s="+s+",i="+i);
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.f(3456);
        test.f(34.56f);
        test.f("abc");
        test.f("abc","def");
        test.f("abc",3456);
    }
}

方法重载有以下几种规则：

• 方法中的参数列表必须不同。比如：参数个数不同或者参数类型不同。
• 重载的方法中允许抛出不同的异常
• 可以有不同的返回值类型，但是参数列表必须不同。
• 可以有不同的访问修饰符。

方法重写

子类可以继承父类的方法，但如果子类对父类的方法不满意，想在里面加入适合自己的一些操作时，就需要将方法进行重写。并且子类在调用方法中，优先调用子类的方法。

比如 Animal 类中有 bark() 这个方法代表了动物叫，但是不同的动物有不同的叫法，比如狗是汪汪汪，猫是喵喵喵。

当然在方法重写时要注意，重写的方法一定要与原父类的方法语法保持一致，比如返回值类型，参数类型及个数，和方法名都必须一致。

重写是涉及子类和父类至少两个类。

八、封装、继承、多态

封装

封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别
这样做有什么好处？

1只能通过规定的方法访问数据。
2隐藏类的实例细节，方便修改和实现。

我们在开汽车的时候，只用去关注如何开车，我们并不在意车子是如何实现的，这就是封装。

如何去实现类的封装呢？

1修改属性的可见性，在属性的前面添加修饰符 (private)
2对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问
3在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定。

如果我们没有在属性前面添加任何修饰符，我们通过对象就可以直接对属性值进行修改，没有体现封装的特性。这在许多程序设计中都是不安全的，所以我们需要利用封装，来改进我们的代码。

首先在类里要将属性前添加 private 修饰符。然后定义 getter 和 setter方法。修改 People.java 和 NewObject.java 的内容如下。

public class People {
    //属性（成员变量）有什么，前面添加了访问修饰符private
    //变成了私有属性，必须通过方法调用
    private double height;     //身高

    //属性已经封装好了，如果用户需要调用属性
    //必须用getter和setter方法进行调用
    //getter和setter方法需要程序员自己定义
    public double getHeight(){
    //getter 方法命名是get关键字加属性名（属性名首字母大写）
    //getter 方法一般是为了得到属性值
      return height;
    }

    //同理设置我们的setter方法
    //setter 方法命名是set关键字加属性名（首字母大写）
    //setter 方法一般是给属性值赋值，所以有一个参数
    public void setHeight(double newHeight){
      height = newHeight;
    }
}

public class NewObject {

    public static void main(String[] args) {
        People LiLei = new People();    //创建了一个People对象LiLei

        //利用setter方法为属性赋值
        LiLei.setHeight(170.0);

        //利用getter方法取属性值
        System.out.println("LiLei的身高是"+LiLei.getHeight());
    }
}

继承

继承可以看成是类与类之间的衍生关系。比如狗类是动物类，牧羊犬类又是狗类。于是我们可以说狗类继承了动物类，而牧羊犬类就继承了狗类。于是狗类就是动物类的子类（或派生类），动物类就是狗类的父类（或基类）。

所以继承需要符合的关系是：is-a，父类更通用，子类更具体。继承的写法如下：

class 子类 extends 父类

为什么需要继承？

如果有两个类相似，那么它们会有许多重复的代码，导致后果就是代码量大且臃肿，后期的维护性不高。通过继承就可以解决这个问题，将两段代码中相同的部分提取出来组成一个父类，实现代码的复用。

继承的特点：

• 子类拥有父类除 private 以外的所有属性和方法。
• 子类可以拥有自己的属性和方法。
• 子类可以重写实现父类的方法。
• Java 中的继承是单继承，一个类只有一个父类。
  注：Java 实现多继承的一个办法是 implements（实现）接口，但接口不能有非静态的属性，这一点请注意。

如我们定义了一个父类 Animal ，再创建一个子类 Dog 类，我们需要子类Dog继承父类 Animal 类。

继承示例：

第一个类：父类

//父类
public class Animal{
	public int legNum;     //动物四肢的数量

	//类方法
    public void bark(){
        System.out.println("动物叫");
    }
}

第二个类：子类，并且继承父类。

Dog 类继承了父类 Animal，我们 Dog 类里什么都没有写，其实它继承了父类 Animal，所以 Dog 类拥有 Animal 类的全部方法和属性（除开 private 方法和属性）。我们创建一个测试类测试一下。

//子类，继承父类
public class Dog extends Animal{
    //重写父类的bark方法
    public void bark(){
        System.out.println("汪汪汪");
    }
}

第三个类：主函数

public class Test1{
    public static void main(String[] args){
        Animal a = new Animal(); //Animal 对象
        Dog d = new Dog();  //Dog 对象

        Animal b = new Dog(); //Dog 对象，向上转型为Animal类型

        a.bark(); //执行Animal类的方法
        d.bark();//执行Dog类的方法
        b.bark();//执行Dog类的方法

    }
}

多态

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

通俗地讲，只通过父类就能够引用不同的子类，这就是多态，我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

多态的实现条件
Java 实现多态有三个必要条件：继承、重写和向上转型（即父类引用指向子类对象）。

只有满足上述三个条件，才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

多态的实现方式
Java 中多态的实现方式：继承父类进行方法重写，抽象类和抽象方法，接口实现。

向上转型

要理解多态必须要明白什么是"向上转型"，比如，一段代码如下，Dog 类是 Animal 类的子类：

Animal a = new Animal();  //a是父类的引用指向的是本类的对象

Animal b = new Dog(); //b是父类的引用指向的是子类的对象

在这里，可以认为由于 Dog 继承于 Animal，所以 Dog 可以自动向上转型为 Animal，所以 b 是可以指向 Dog 实例对象的。

注：不能使用一个子类的引用去指向父类的对象，因为子类对象中可能会含有父类对象中所没有的属性和方法。（只能父类引用子类，子类不能引用父类）

如果定义了一个指向子类对象的父类引用类型，那么它除了能够引用父类中定义的所有属性和方法外，还可以使用子类强大的功能。但是对于只存在于子类的方法和属性就不能获取。例如：

class Animal{
    //父类方法
    public void bark(){
        System.out.println("动物叫！");
    }
}

class Dog extends Animal{
    //子类重写父类的bark方法
    public void bark(){
        System.out.println("汪！汪！汪！");
    }

    //子类自己的方法
    public void dogType(){
        System.out.println("这是什么品种的狗");
    }
}

public class Test{
    public static void main(String[] args){
        Animal a = new Animal();
        Animal b = new Dog();
        Dog d = new Dog();

        a.bark();
        b.bark();

        d.bark();
        d.dogType();

        //注意：如果是b.dogType()则会编译不通过
    }
}

super

super 关键字在子类内部使用，代表父类对象。

1访问父类的属性 super.属性名。
2访问父类的方法 super.bark()。
3子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()。

九、抽象类

类本来就是抽象的，而抽象类则是指类中有抽象方法。
在定义类时，前面加上abstract关键字修饰的类叫抽象类。

抽象类中有抽象方法，这种方法是不完整的，仅有声明而没有方法体。抽象方法声明语法如下

abstract void f();  //f()方法是抽象方法

那我们什么时候会用到抽象类呢？

1、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法，而并不关注方法如何去实现。

2、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

所以由上可知，抽象类是限制规定子类必须实现某些方法，但不关注实现细节。

那抽象类如何用代码实现呢，它的规则如下：

1、用 abstract 修饰符定义抽象类。
2、用 abstract 修饰符定义抽象方法，只用声明，不需要实现。
3、包含抽象方法的类就是抽象类。
4、抽象类中可以包含普通的方法，也可以没有抽象方法。
5、抽象类的对象不能直接创建，通常是定义引用变量指向子类对象。

抽象类实现：

//写一个抽象的父类
public abstract class TelePhone{
    public abstract void call(); // 抽象方法，打电话
    public abstract void message(); //抽象方法，发短信
}

//子类继承父类
public class CellPhone extends TelePhone{
    @Override //重写
    public void call(){
        System.out.println("我可以打电话");
    }

    @Override 
    public void message(){
        System.out.println("我可以发短信");
    }

    public static void main(String[] args){
        CellPhone cp = new CellPhone();
        cp.call();
        cp.message();
    }
}

十、接口

接口用于描述类所具有的功能，而不提供功能的实现，功能的实现需要写在实现接口的类中，并且该类必须实现接口中所有的未实现方法。

接口的声明语法格式如下：

修饰符 interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

如声明一个Animal接口

// Animal.java
interface Animal {
        //int x;
        //编译错误,x需要初始化，因为是 static final 类型
        int y = 5;
        public void eat();
        public void travel();
}

注意点

在 Java8 中：

• 接口不能用于实例化对象。
• 接口中方法只能是抽象方法、default 方法、静态方法。
• 接口成员是 static final 类型。
• 接口支持多继承。

在 Java9 中，接口可以拥有私有方法和私有静态方法，但是只能被该接口中的 default 方法和静态方法使用。

多继承实现方式：

修饰符 interface A extends 接口1，接口2{

}

修饰符 class A implements 接口1，接口2{

}

实现上面的接口

// Cat.java
public class Cat implements Animal{

     public void eat(){
         System.out.println("Cat eats");
     }

     public void travel(){
         System.out.println("Cat travels");
     }
     public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        cat.travel();
    }
}

十一、内部类

将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。

内部类的主要作用如下：

1、内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2、内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3、内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

4、内部类允许继承多个非接口类型（具体将在以后的内容进行讲解）

注：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量方法名可以和外部类的相同。

我们通过代码来详细学习一下内部类吧！

public class People{
    private String name = "Lilei"; //外部类的私有属性

    // 内部类Strudent
    public class Student{
        String ID = "20151234"; //内部类的成员属性

        // 内部类的方法，该方法访问外部类和内部类
        public void stuInfo(){
            System.out.println("访问外部类中的name："+name);
            System.out.println("访问内部类中的ID+"+ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args){
        People a = new People(); //创建外部类对象，对象名为a
        Student b = a.new Student(); //使用外部类对象创建内部类对象，对象名为b
        b.stuInfo(); //调用内部对象的studInfo方法
    }
}

成员内部类的使用方法：

1、Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符。
2、Student 类在 People 类里，所以访问范围在类里的所有方法均可以访问 People 的属性（即内部类里可以直接访问外部类的方法和属性，反之不行）。
3、定义成员内部类后，必须使用外部类对象来创建内部类对象，即 内部类 对象名 = 外部类对象.new 内部类();。
4、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如上述代码中：a.this。

注：成员内部类不能含有static的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。

静态内部类

静态内部类通常被称为嵌套类。

public class People{
    private String name = "Lilei"; //外部类的私有属性

    /*
    外部类的静态变量
    java中被static修饰的成员称为静态成员或类成员。它属于整个类所有，
    而不是某个对象所有，即被类的所有对象所共享。（因此成员的内部类不能
    含有static的变量或方法）。静态成员可以是使用类名直接访问，也可以使用
    对象名进行访问。
    */
    static String ID = "1732111237893165";

    // 静态内部类Strudent，主要，static修饰的是内部类，而不是变量或方法。
    public static class Student{
        String ID = "20151234"; //内部类的成员属性

        // 内部类的方法，该方法访问外部类和内部类
        public void stuInfo(){
            System.out.println("访问外部类中的name："+ (new People().name));
            System.out.println("访问外部类中的ID: "+ People.ID);
            System.out.println("访问内部类中的ID： "+ ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args){
        //People a = new People(); //创建外部类对象，对象名为a
        Student b = new Student(); //使用外部类对象创建内部类对象，对象名为b
        b.stuInfo(); //调用内部对象的studInfo方法
    }
}

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、静态内部类不能直接访问外部类的非静态成员，但可以通过 new ().成员 外部类的方式访问。

2、如果外部类的静态成员与内部类的成员名称相同，可通过 类名.静态成员 访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过 成员名 直接调用外部类的静态成员。

3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();。

局部内部类

局部内部类，是指内部类定义在方法和作用域内。
作用域和方法的区别？

public class People{
    //定义在外部类中的方法内
    public void peopleInfo(){
        final String sex = "man"; //外部类方法中的常量

        class Student {
            String ID = "2015305650"; //内部类中的常量

            public void print(){
                System.out.println("访问外部类的方法中的常量sex： " + sex); 
                System.out.println("访问内部类中的变量ID: " + ID);
            }
        }

        Student a = new Student();  //创建方法内部类的对象
        a.print(); //调用内部类的方法
    }

    //定义在外部类中的作用域内?这句话怎么理解呢
    public void peopleInfo2(boolean b){
        if(b){
            final String sex = "man"; //外部类方法中的常量
            class Student {
                String ID = "20153546"; //内部类中的常量

                public void print(){
                    System.out.println("访问外部类的方法中的常量sex： " + sex);
                    System.out.println("访问内部类中的变量ID： " + ID); 
                }
            }
            Student a = new Student(); //创建方法内部类的对象
            a.print(); // 调用内部类的方法
        }
    }

    //测试方法内部类
    public static void main(String[] args){
        People b = new People(); //创建外部类的对象
        System.out.println("定义在方法内： ================");
        b.peopleInfo();  //调用外部类的方法
        System.out.println("定义在作用域内： ================");
        b.peopleInfo2(true);
    }
}

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

匿名内部类

匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

// Outer.java
public class Outer {

    public Inner getInner(final String name, String city) {
        return new Inner() {
            private String nameStr = name;
            public String getName() {
                return nameStr;
            }
        };
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.getInner("Inner", "NewYork");
        System.out.println(inner.getName());
    }
}
interface Inner {
    String getName();
}

运行结果：Inner。

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的, 如果不先定义，编译时会报错该类找不到。

同时，在上面的例子中，当所在的方法的形参需要在内部类里面使用时，该形参必须为 final。这里可以看到形参 name 已经定义为 final 了，而形参 city 没有被使用则不用定义为 final。

然而，因为匿名内部类没名字，是用默认的构造方法的，无参数的，如果需要该类有带参数的构造方法，示例如下：

public Inner getInner(final String name, String city) {
  return new Inner(name, city) {
    private String nameStr = name;

    public String getName() {
      return nameStr;
    }
  };
}

注意这里的形参 city，由于它没有被匿名内部类直接使用，而是被抽象类 Inner 的构造方法所使用，所以不必定义为 final。

十二、package

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用

• 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
• 包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。
• 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

定义包语法：

package 包名
//注意：必须放在源程序的第一行，包名可用"."号隔开

例如：

//在定义文件夹的时候利用"/"来区分层次
//包中用"."来分层
package com.shiyanlou.java

不仅是我们这样利用包名来区分类，系统也是这样做的。

使用 import 关键字。比如要导入包 com.shiyanlou 下 People 这个类，import com.shiyanlou.People;。同时如果 import com.shiyanlou.*; 这是将包下的所有文件都导入进来，* 是通配符。

包的命名规范是全小写字母拼写。