面向对象——权限修饰符、匿名内部类

package关键字

为什么要有包？
将字节码（.class）进行分类存放
包其实就是文件夹

包的定义及注意事项

定义包的格式
package 包名
多级包用.分割，如package com.heima里面的.就是分隔符

定义包的注意事项

1. package语句必须是程序的第一条可执行的代码
2. package语句在一个Java文件中只能有一个
3. 如果没有package默认表示无包名

cmd如何编译运行带包的类

1. javac编译的时候带上-d即可，例如javac -d.HelloWorld.java
2. 通过java命令执行，java 包名.HelloWorld
   不同包下类之间的访问

import关键字

为什么会有import？
其实就是让有包的类对调用者可见，不用写全类名了

导包格式：

• import包名
• 这种方式导入是到类的名称，最后可以写*通配符但是不建议
  package语句子啊java文件中第一个
  import在中间
  class在package和import下面

没有导包前每次访问其他类都需要写包名

导包后不用在写包名

*通配符

权限修饰符

结论：

protected

面向对象—类及其组成所使用的常见修饰符

修饰符

• 权限修饰符：private，默认的（default），protected，public
• 状态修饰符：static，final
• 抽象修饰符：abstract

类

• 权限修饰符：默认的（default），public（用的最多）
• 状态修饰符：final
• 抽象修饰符：abstract

成员变量

• 权限修饰符：private（用的最多），默认的，protected，public
• 状态修饰符：static，final

构造方法

• 权限修饰符：private，默认的，protected，public（用的最多）

成员方法

• 权限修饰符：private，默认的，protected，public（用的最多）
• 状态修饰符：static，final
• 抽象修饰符：abstract

组合规则

• 成员变量：public static final（接口成员变量）
• 成员方法：
  1、public static；
  2、public final；
  3、public abstract

内部类概述和访问特点

内部类概述：被定义为在另一个类中声明的类
内部类的访问特点：1、内部类可以直接访问外部类的成员，包括私有；2、外部类访问内部类成员必须向创建类，格式为：外部类名.内部类名 对象名 = 外部类对象.内部类对象

练习代码

public class InnerClass {
    public static void main(String[] agrs) {
        //创建内部类对象，外部类访问内部类的成员必须创建对象，格式为：外部类名.内部类名 对象名 = 外部类对象.内部类对象
        out.inner oi = new out().new inner();
        oi.print();
    }
}

class out {
    private int num = 15;

    class inner {
        public void print() {
            System.out.println(num);//内部类直接访问外部类成员变量，包括私有
        }
    }
}

输出结果：

成员内部类的私有使用

练习代码

public class InnerClass {
    public static void main(String[] agrs) {
        //创建内部类对象，外部类访问内部类的成员必须创建对象，格式为：外部类名.内部类名 对象名 = 外部类对象.内部类对象
        //out.inner oi = new out().new inner();
        //oi.print();无法访问私有的方法
        
        //实例化out类，然后访问类中的方法
        out o = new out();
        o.print();
    }
}
class out {
    private int num = 15;

    class inner {
        private void print() {
            System.out.println(num);//内部类直接访问外部类成员变量，包括私有
        }
    }

    //在本类创建一个public公用方法来访问本类的private方法
    public void print() {
        out.inner oi = new out().new inner();
        oi.print();
    }
}

运行结果

静态成员内部类

访问静态内部类的格式：外部类名.内部类名 对象名 = 外部类名.内部类对象

练习代码

public class StaticClass {
    public static void main(String[] agrs) {
        //访问静态内部类的格式：外部类名.内部类名 对象名 = 外部类名.内部类对象
        Outer.Inner OI = new Outer.Inner();
        OI.methed();

//访问静态内部类中静态方法
        Outer.Inner1.methed1();
    }
}

class Outer {
    static class Inner { //静态内部类
        public void methed() {
            System.out.println("静态内部类的输出");
        }
    }

    static class Inner1 {
        public static void methed1() {
            System.out.println("静态内部类+静态方法的输出");
        }
    }
}

内部类之所以能获取到外部类的成员，是因为他能获取到外部类的引用，外部类名.this

局部内部类访问局部变量

局部内部类访问局部变量必须用final修饰
原因：因为当调用这个方法时，局部变量如果没有final修饰，他的生命周期和方法的生命周期一样，当方法弹栈，局部变量消失，如果局部内部类对象还没有马上消失，想用这个变量就没有了，如果用final修饰会在类加载的时候进入常量池，即使方法弹栈，常量池的常量还在也可以继续使用，但是jdk1.8取消了这个规则，感觉是bug
练习代码

package com.Demo08;

public class Demo08_InnerTest {
    public static void main(String[] agrs) {
        Outerr o = new Outerr();
        o.Outmethed();
    }
}

class Outerr {
    public void Outmethed() {
        final int n = 20;//局部内部类访问局部变量必须用final修饰
        class inner {
            public void Innermethed() {
                System.out.println("hello");
                System.out.println(n);
            }
        }
        inner i = new inner();
        i.Innermethed();
    }
}

运行结果

匿名内部类的格式和理解

匿名内部类就是内部类的简化写法
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
格式：new 类名或者接口名（）{重写方法}
本质上是一个继承了该类或者实现了该接口的子类匿名对象

练习代码

package com.Demo08;

public class Demo08_nonameclass {
    public static void main(String[] agrs) {
        name name = new name();
        name.mehted();

    }
}

interface inter {
    public void print();
}

class name {
    class name1 implements inter { //有名字的内部类

        public void print() {
            System.out.println("有名字的内部类");
        }
    }

    public void mehted() {
        name1 n = new name1();
        n.print();

        //inter的子对象 new inter是实现inter
        new name1().print();
        new inter() {                            //实现了inter接口
            public void print() {                //重写了抽象方法
                System.out.println("匿名内部类");
            }
        }.print();//后面的print相当于执行方法
    }
}

运行结果

匿名内部类重写多个方法调用

匿名内部类只针对重写一个方法时候使用
匿名内部类不能向下转型
练习代码

public class Demo08_nonameclass {
    public static void main(String[] agrs) {
        name name = new name();
        name.mehted();
    }
}

interface inter {
    public void print1();
    public void print2();
}

class name {
    class name1 implements inter { //有名字的内部类
        public void print1() {
            System.out.println("有名字的内部类1");
        }

        public void print2() {
            System.out.println("有名字的内部类2");
        }
    }

    public void mehted() {
        name1 n = new name1();
        n.print1();
        n.print2();

        //inter的子对象 new inter是实现inter
        // new name1().print1();
        inter i = new inter() {                     //实现了inter接口
            public void print1() {                //重写了抽象方法1
                System.out.println("匿名内部类1");
            }

            public void print2() {                //重写了抽象方法2
                System.out.println("匿名内部类2");
            }
        };//.print();//后面的print相当于执行方法
        i.print1();
        i.print2();
    }
}

运行结果

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

练习代码

public class NoNameClassTest {
    public static void main(String[] agrs) {
        persondemo pd = new persondemo();
        pd.method(new student() {  //匿名内部类当作参数传递（本质把匿名内部类看作一个对象）
            public void show() {
                System.out.println("匿名内部类在开发中的应用 1");
            }
        });
    }
}

abstract class person {
    public abstract void show();
}

class persondemo {
    public void method(person p) { //person p = new student();
        p.show();
    }
}

class student extends person {
    public void show() {
        System.out.println("匿名内部类在开发中的应用");
    }
}

运行结果