Java 类包

类名冲突

完整的类路径

例如，一个程序中同时使用到java.util.Date类与java.sql.Date类，如果在程序中不指定完整类路径，编译器不会知道这段代码使用的是java.util类包中的 Date 类还是java.sql类包中的 Date 类，所以需要在指定代码中给出完整的类路径。

创建包

在类中定义包名的语法格式：

package 包名

导入包（import）

使用 import 关键字导入包，可以指定类的完整描述，如果要使用包中更多的类，使用 import 关键字在包指定后加上 *，表示在程序中使用包中的所有类。

（2）使用 import 导入静态成员

import 关键字除了导入包之外，还可以导入静态成员，这是 JDK 5.0 以上版本提供的功能。

使用 import 导入静态成员的语法格式：

import static 静态成员

示例：

package com.ccc;

import static java.lang.Math.max; //导入静态成员方法
import static java.lang.System.out; //导入静态成员变量

publci class ImportTest {
    public static void main(String[] args) {
        //
        out.println("1 和 4 的较大值为： " + max(1,4));
    }
}

内部类

内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

public class People{
    // 内部类
    public class Heart{
    }
}

内部类的使用场景

场景：当一个事物的内部，还有一个部分需要一个完整的结构进行描述时。

基本作用

内部类通常可以方便访问外部类的成员，包括私有的成员。
内部类提供了更好的封装性，内部类本身就可以用 private ，protectecd 等修饰，封装性可以做更多控制。

内部类的分类

静态内部类
成员内部类（非静态内部类）
局部内部类
匿名内部类

静态内部类

public class Outer{
    // 静态成员内部类
    public static class Inner{
    }
}

静态内部类创建对象的格式：

格式：
    外部类名.内部类名 对象名 = new 外部类名.内部类构造器;
示例：
    Outer.Inner in =  new Outer.Inner();

静态内部类的访问拓展：

1、静态内部类中是否可以直接访问外部类的静态成员？

可以，外部类的静态成员只有一份可以被共享访问。

2、静态内部类中是否可以直接访问外部类的实例成员？

不可以的，外部类的实例成员必须用外部类对象访问。

静态内部类总结：

静态内部类的使用场景、特点、访问总结。

如果一个类中包含了一个完整的成分，如汽车类中的发动机类。
特点、使用与普通类是一样的，类有的成分它都有，只是位置在别人里面而已。
访问总结：可以直接访问外部类的静态成员，不能直接访问外部类的实例成员。
注意：开发中实际上用的还是比较少。

成员内部类

成员内部类的定义位置：在类中方法，跟成员变量是一个位置

public class Outer {
    // 成员内部类
    public class Inner {

    }
}

成员内部类创建对象的格式（外界创建成员内部类）：

格式：
    外部类名.内部类名 对象名 = new  外部类构造器.new 内部类构造器();

范例：
    Outer.Inner in =  new Outer().new  Inner();

成员内部类的推荐使用方案

将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有

化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

示例代码：

class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
//Outer.Inner oi = new Outer().new Inner();        
//oi.show();        
        Outer o = new Outer();
        o.method();
    }
}

成员内部类的访问拓展：

1、成员内部类中是否可以直接访问外部类的静态成员？

可以，外部类的静态成员只有一份可以被共享访问。

2、成员内部类的实例方法中是否可以直接访问外部类的实例成员？

可以的，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

成员内部类的总结：

1、成员内部类是什么样的、有什么特点？

- 无 static 修饰，属于外部类的对象。
- 可以直接访问外部类的静态成员，实例方法中可以直接访问外部类的实例成员。

2、成员内部类如何创建对象？

外部类名.内部类名对象名 = new 外部类构造器.new 内部类构造器();

案例：成员内部类-面试笔试题

请观察如下代码，写出合适的代码对应其注释要求输出的结果。

    class People{
        private int heartbeat = 150;
        public class Heart{
            private int heartbeat = 110;
            public void show(){
                int heartbeat = 78;           System.out.println(??); // 78           System.out.println(??); // 110            System.out.println(??); // 150
        }
    }
}

注意：在成员内部类中访问所在外部类对象 ，格式：外部类名.this。

局部内部类

局部内部类定义位置
- 局部内部类是在方法中定义的类，放在方法、代码块、构造器等执行体中。
局部内部类使用方式
- 局部内部类，外界是无法直接使用的，需要在方法内部创建对象并使用
- 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
示例代码

class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类

匿名内部类的本质

匿名内部类的作用

匿名内部类的前提

匿名内部类的格式

// 格式
new 类|抽象类名|或者接口名() {
    重写方法;
};

// 示例1
new Inter(){
    @Override
    public void method(){}
}

// 示例2
Employee a = new Employee() {
    public void work() {

    }
};
a. work();

匿名内部类的特点

匿名内部类的细节

Inter i = new Inter(){
  @Override
    public void method(){
       
    }
}

匿名内部类的使用

/*
    游泳接口
*/
public interface Swimming {
    void swim();
}

/* 测试类*/
public class JumppingDemo {
    public static void main(String[] args) {
        //需求：goSwimming方法
    }

    // 定义一个方法让所有角色进来一起比赛
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

使用总结：匿名内部类可以作为一个对象，直接传输给方法。

匿名内部类直接调用方法

interface Inter{
    void method();
}
class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method(); // 直接调用方法
    }
}

应用：匿名内部类在开发中的使用

当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的

代码

示例代码：

interface Jumpping {
    void jump();
}
class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
class Dog implements Jumpping {
    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}
class JumppingOperator {
    public void method(Jumpping j) { //new Cat();   new Dog();
        j.jump();
    }
}
class JumppingDemo {
    public static void main(String[] args) {
        //需求：创建接口操作类的对象，调用method方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.method(j);
        Jumpping j2 = new Dog();
        jo.method(j2);
        System.out.println("");
        // 匿名内部类的简化
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });
// 匿名内部类的简化        
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高了");
            }
        });
    }
}

给按钮绑定点击事件

//  为按钮绑定点击事件监听器。
btn.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("登录一下~~");
    }
});
      // 简化
//  btn.addActionListener(e -> System.out.println("登录一下~~"));

使用总结：

匿名内部类通常是在开发中调用别人的方法时，别人需要我们写的时候才会定义出来使用。
将来：匿名内部类还可以实现进一步的简化代码（后面其他技术会讲）

内容目录

java

Java 类包

内部类