java导包与内部类

一：导包

package：到达路径为包
import：最终导的是一个类
package：放在java文件的第一行，表示将来编译运行的时候路径
import：放在package和class之间的
class：是最后出现的，表示我们要写的程序代码
权限修饰符： 同一类下 | 同一包子类，其他类 | 不同包子类 | 不同包其他类

​ public √ √ √ √

​ protected √ √ √ ×

​ 默认 √ √ × ×

​ private √ × × ×

二、形式参数：

基本数据类型：byte、short、int、long、float、double、char、boolean
​ 引用数据类型：
​ 类：当类作为方法的形式参数的时候，实际上需要的该类的对象。
​ 抽象类：当抽象类作为方法的形式参数的时候，使用多态的形式创建对象。将来看到当一个抽象方法作为形式参数类型的时候，实际上需要的是子类实现对象的地址值，利用多态的性质。
​ 接口：当接口作为方法的形式参数的时候,使用接口多态的形式创建对象。将来看到当接口作为形式参数传入的时候，实际上需要的是该接口的实现类的对象的地址值，利用接口多态的性质。
​ 数组：

三、返回值的问题：

基本数据类型：
应用数据类型：
​ 类：当类作为方法的返回值的时候，实际上返回的是该的对象
​ 抽象类：当抽象类作为方法的返回值的时候,需要的是该抽象类子类的对象
​ 接口：当接口作为方法的返回值的时候,需要的是实现该接口的类的对象
链式编程(后面大家会学习scala,spark,flink)
new TeacherDemo2().getPlayGame().playLoL();

四、内部类

​ 把类定义在其他类的内部，我们称之为内部类
内部类有哪些特点
​ 1、内部类可以访问外部类的成员，包括私有
​ 2、外部类要想访问内部类的成员，就必须要创建内部类的对象

class Outer{
​    private int num = 10;
​    class Inner{
​        public void show(){
​            System.out.println(num);
​        }
​    }
​    public void show2(){
//        show();
​        //创建内部类对象
​        Inner inner = new Inner();
​        inner.show();
​    }
}
public class InnerClassDemo1 {
​    public static void main(String[] args) {
​    }
}

根据内部类定义的位置不同，可以分为一下两种类型
​ 成员的位置上（成员内部类）
​ 局部的位置上（局部内部类）

class Outer2{
​    //定义在成员的位置上（成员内部类）
​    class Inner2{
​    }
​    public void fun(){
​        //定义在局部范围内（局部内部类）
​        class Inner3{
​        }
​    }
}
public class InnerClassDemo2 {
}

成员内部类：
​ 1、内部类可以访问外部类的成员，包括私有
​ 2、外部类要想访问内部类的成员，就必须要创建内部类的对象

class Outer3{
​    private int num = 10;
​    class Inner{
​        public void show(){
​            System.out.println(num);
​        }
​    }
}
public class InnerClassDemo3 {
​    public static void main(String[] args) {
​        //需求：我现在想要访问Inner类中的show()方法,就必须得创建对象
//        Inner inner = new Inner();
//        inner.show();
​        //正确创建内部类的格式
​        //外部类名.内部类名 对象名 =new 外部类对象.new 内部类对象;
​        Outer3.Inner oi = new Outer3().new Inner();
​        oi.show();
//        Outer3 outer3 = new Outer3();
//        Outer3.Inner inner = new Outer3().new Inner();
//        inner.show();
​    }
}

成员内部类常见的修饰符为：
​ private:为了保证数据安全性
​ static:为了方便访问数据
静态修饰的特点：
​ 内部类如果是静态修饰的，只能访问外部类静态的成员

class Outer4{
​    private int num = 10;
​    private static int num2 = 30;
​    static class Inner4{
​        public void show(){
//            System.out.println(num);
​            System.out.println(num2);
​        }
​       public static void show2(){
//            System.out.println(num);
​            System.out.println(num2);
​        }
​    }
}
public class InnerClassDemo4 {
 public static void main(String[] args) {
​        //Error:(33, 29) java: 限定的新静态类
//        Outer4.Inner4 oi4 = new Outer4().new Inner4();
//        oi4.show();
​        //当内部类是被静态所修饰的时候，出现了另一个创建内部类的格式
​        //访问格式如下：
​        //外部类类名.内部类类名 变量名 = new 外部类类名.内部类类名();
​        Outer4.Inner4 oi4 = new Outer4.Inner4();
​        oi4.show();
//        oi4.show2();
​        Outer4.Inner4.show2();
​    }
}

注意事项：
内部类与外部类没有继承关系。
局部内部类：
​ 1、可以直接访问外部类的所有成员
​ 2、可以在外部类中的局部范围中创建对象，通过对象调用
​ 内部类中的方法，来使用内部类的局部功能。

class Outer6{
​    private int num = 10;
​    public void fun(){
​        int num2 = 100;
​        class Inner6{
​            int num3 = 200;
​            public void show(){
//                num3 = 300;
​                //从内部类引用的本地变量必须是最终变量或实际上的最终变量
//                num2 = 400;
​                //通过反编译工具查看后发现局部内部类存在的方法中定义的局部变量num2自动加上了final
​                //特点：jdk1.8之后会自动添加final关键字。
​               System.out.println(num);
​                System.out.println(num2);
​                System.out.println(num3);
​            }
​        }
​        //创建内部类对象
​        Inner6 inner6 = new Inner6();
​        inner6.show();
​    }
​    public void fun2(){
​        //方法与方法之间内部访问不到局部内部类
//        Inner6 inner6 = new Inner6();
​    }
}
public class InnerClassDemo6 {
​    public static void main(String[] args) {
​        Outer6 outer6 = new Outer6();
​        outer6.fun();
​    }
}

匿名内部类：

多态：
interface A{
​    b();
​    c();
}
class B implements A{
​    b(){..}
​    c(){..}
}
A a = new B();
匿名内部类：
A a = new A(){
​    b(){..}
​    c(){..}
};

匿名内部类：
​ 就是内部类的一个简化写法。
存在匿名内部类的前提：
​ 要存在一个类或者是一个接口，类可以是具体的类也可以是抽象类
定义格式：
​ new 类名或者接口名(){重写方法;}
本质上：
​ 是一个继承了这个类或者实现了这个接口的子类匿名对象
匿名内部类在开发中的使用：

interface Person{
​    public abstract void study();
}
class PersonDemo{
​    Person person;
​    PersonDemo(Person person){  //接口作为参数
​        this.person = person;
​    }
​    //当接口作为方法的参数的时候，实际上需要的是实现该接口类的对象
//    public void fun(Person person){
//        person.study();
//    }
}
class Student implements Person{
​    @Override
​    public void study() {
​        System.out.println("好好学习天天向上");
​    }
}
public class InnerClassDemo8 {
​    public static void main(String[] args) {
//        PersonDemo pd = new PersonDemo();
//        Student student = new Student();
//        pd.fun(new Student());
​        //使用匿名内部类的形式
//        pd.fun(new Person() {
//            @Override
//            public void study() {
//                System.out.println("好好学习匿名内部类");
//            }
//        });
//        PersonDemo personDemo = new PersonDemo(new Student());
​        //使用匿名内部类的形式创建对象
​        PersonDemo pd = new PersonDemo(new Person() {
​            @Override
​            public void study() {
​                System.out.println("好好学习使用匿名内部类创建对象");
​            }
​        });
​        Person person = pd.person;
​        person.study();
//       new PersonDemo(new Person() {
//            @Override
//            public void study() {
//                System.out.println("好好学习使用匿名内部类创建对象");
//            }
//        }).person.study();
​    }
}