今日主要内容：包,修饰符总结,内部类

包

所谓包，可以说就是一个文件夹。通过定义包，可以管理字节码文件，也产生了不同的访问权限。
包的定义：在源文件的第一个可执行语句中用package 声明。一般通过域名的反写命名，如package com.gdut.java;
在定义的包之后，在控制台执行编译的语句也发生了变化，在源文件所在目录下打开控制台输入javac -d . filename.java,运行则要输入文件的全名，即要包括包名
java com.gdut.java.filename
包的产生，也产生了protected访问权限。说到访问权限，之前说private是对类的封装，因为限制了其他类访问该类内部成员的方式。但并不是说封装就是private，而只能说private是封装的一种形式，封装是相对的，在不同包下，用默认权限修饰符修饰的类就不允许其他包的类对其访问，也是一种封装形式。
视频中老师说了一个例子，生动形象hhhhh，教室的学生要访问他的钱包是不允许的，这是违法，他的钱包对学生就是封装的，当他回到家，他老婆要访问他的钱包是可以的，不然就是作死，他的钱包对他老婆就不是封装的，所以说封装是相对的。

修饰符总结

权限修饰符权限表

• 修饰符
• 权限修饰符：private,默认,protected,public
• 状态修饰符：final,static
• 抽象修饰符：abstract
• 类
• 权限修饰符：默认，public
• 状态修饰符：final
• 抽象修饰符：abstract
• 成员变量
• 权限修饰符：private,默认,protected,public
• 状态修饰符：final,static
• 构造方法
• 权限修饰符：private,默认,protected,public
• 成员方法
• 权限修饰符：private,默认,protected,public
• 状态修饰符：final,static
• 抽象修饰符：abstract

内部类

内部类，顾名思义就是定义在类内部的类。按照内部类所在的区域可以分为成员内部类和局部内部类。局部内部类就是定义在方法中的内部类。

• 成员内部类
  内部类可以直接访问外部类的变量，包括私有变量，但外部类要访问内部类成员必须要创建对象
  其他类创建内部类对象的方法：外部类名.内部类名 = new 外部类名() .new 内部类名();其实，只要把内部类当做外部类的成员就很好理解，new 外部类名()就是创建外部类对象，用点表示引用其成员，由于该成员是个类，所以要创建对象，new 内部类名()；于是上面的语句可以理解为外部类名.内部类名 = 外部类对象.内部类对象

class Demo_InnerClass {
    public static void main(String[] args) {
        //外部类名.内部类名 = 外部类对象.内部类对象
        Outer.Inner io = new Outer().new Inner();   
        io.print();                                 
        new Outer().new Inner().print();            //匿名引用
    }
}
class Outer{
    private int num = 10;                   //外部类要访问内部类成员必须创建对象
    class Inner{
        public void print(){
            System.out.println(num);        //内部可以访问外部类成员变量,即使私有
        }   
    }
}

• 静态内部类

class Outer{
          private int num = 10;                 
          static class Inner2{                  //静态成员内部类
                 public void print(){
                 System.out.println("inner2");
           }
    }

在创建静态内部类对象时，不用创建外部类对象，即Inner i =Outer.new Inner2();
但由于书写习惯，编译器不允许这样的语句，要将new提前，于是变成
Inner i =new Outer.Inner2()

• 局部内部类
  局部内部类与普通内部类大致相同，但有一个应特别注意的地方，内部类所在方法的局部变量必须用final修饰，即要变成常量，否则编译会报错，但在jdk1.8版本中取消了该机制，个人理解这应该是个bug。采用这种机制的原因如下：
  当调用这个方法时,不用final修饰,局部变量的声明周期和该方法时一致的,当方法弹栈,这个局部变量也会消失,如果局部内部类对象没有马上消失,仍想调用该局部变量,该局部变量就没有了,用final修饰的变量会进入常量池,即使方法弹栈,常量池中的变量依然存在,仍然可以使用。
  通过内存图理解这一原因

  
  
  局部内部类内存图
  
  

  练习代码

class Demo_InnerClass3 {                        //局部内部类(方法内部类)
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}
class Outer {
    public void method(){
        final int num =10;          //局部内部类成员方法必须是常量,防止在方法弹栈后对象无法使用该值
        class Inner{
            public void print(){
                System.out.println(num);
            }
        }

        Inner i = new Inner();
        i.print();
    }
}

• 匿名内部类
  可能很多人在匿名内部类这里会很晕。其实，只要看到它的实质就很容易理解他的用法。他的实质就是将：1、创建一个类继承或实现某接口2、重写其抽象方法3、创建对象 三个步骤融合到一个语句中进行简化。本质是一个继承了该类或者实现了该接口的子类匿名对象
  从上面的本质也看出了其存在的前提：在一个方法内，有可以继承的父类或可以实现的接口。
  从下面的题目理解

class Demo_NonameClass2 {
    public static void main(String[] args) {
        //如何调用PersonDemo中的method方法
        PersonDemo pd = new PersonDemo();
        }
}
abstract class Person{
    public abstract void show();
}
class PersonDemo{
    public void method(Person p){       //父类引用指向子类对象
        p.show();
    }
}

题目中要求用Person为参数，但Person是接口，无法创造实例，只能通过创建他的子类来实现。
方法一：创建有名字的类，实现Person接口，重写里面的show()方法，再创建该类的对象作为参数传入pd中的method方法。创建了Student类实现接口，创建Student类作为method的方法。

class Demo_NonameClass2 {
    public static void main(String[] args) {
        //如何调用PersonDemo中的method方法
        PersonDemo pd = new PersonDemo();
        //写有名字的类
        pd.method(new Student());               //showname
        }
}
abstract class Person{
    public abstract void show();
}
class PersonDemo{
    public void method(Person p){       //父类应用指向子类对象
        p.show();
    }
}
class Student extends Person{
    public void show(){
        System.out.println("showname");
    }
}

方法而：通过匿名内部类，省略创建一个新的有名字的类的过程。

class Demo_NonameClass2 {
    public static void main(String[] args) {
        //如何调用PersonDemo中的method方法
        PersonDemo pd = new PersonDemo();
        //用匿名内部类
        pd.method(new Person(){                 //匿名内部类当做参数传递           
            public void show (){
                System.out.println("shownoname"); //showname
            }
        });
    }
}
abstract class Person{
    public abstract void show();
}

new Person()可以看做是创建一个匿名的Person的接口并创建对象，之后的大括号就是对接口的实现，即重写方法。就省略了创建新类的过程。

• 弊端：上面的例子看到了匿名内部的好处，但也是有弊端的，就是显然，每次使用匿名内部类要重写全部的抽象方法，当其继承的类或者接口的抽象方法很多时，直接写有名的类效率更高。而且，由于匿名内部类没有名字，不能进行向下转型，故无法调用其特有的方法。

到目前为止大致学完了JAVA有关面向对象的所有概念，接下来转向JAVA标准类库用法的学习，即API的学习。