day10-Java面向对象(包/内部类/匿名类)

10.01_面向对象(package关键字的概述及作用)(了解)

• A:为什么要有包
  • 将字节码(.class)进行分类存放
  • 包其实就是文件夹
• B:定义包的格式
  • package 包名;
  • 多级包用.(英文逗号)分开即可

package com.baidu;

// A:package语句必须是程序的第一条可执行的代码
// B:package语句在一个java文件中只能有一个
// C:如果没有package，默认表示无包名
    
class TestJava {
}

10.03_面向对象(带包的类编译和运行)(掌握)

// 编译
javac -d . TestJava.java

// 运行带包的类
java com.baidu.TestJava
```

###10.05_面向对象(import关键字的概述和使用)(掌握)
* A:案例演示
    * 为什么要有import
        * 其实就是让有包的类对调用者可见,不用写全类名了 
* B:导包格式
    * import 包名;
    * 这种方式导入是到类的名称。
    * 虽然可以最后写*，但是不建议。

```Java
// 不使用import的方式
com.houwan.Person p = new com.houwan.Person("Hou",24);
System.out.println(p.getName()+"--->"+p.getAge());

// 先用import之后
import com.houwan.Person;

Person p = Person("Hou",24);

// 注意 class /  import  / package 的顺序必须是
package(只有一个) --> import(可以多个) --> class
```

###10.06_面向对象(四种权限修饰符的测试)(掌握)

|             | 本类   |  同一个包下(子类+无关类)   |  不同包下(子类) | 不同包下(无关类) |
| :--------:  | :--------:     | :--------:   | :--------: | :--------: |
| `private`     | Y |  | | |
| 默认        | Y | Y| | |
| `protected`   | Y | Y|Y| |
| `public`      | Y | Y | Y | Y |


###10.07_面向对象(类及其组成所使用的常见修饰符)(掌握)
* A:修饰符：
    * 权限修饰符：`private`，默认的，`protected`，`public`
    * 状态修饰符：`static`，`final`
    * 抽象修饰符：`abstract`
* B:类：
    * 权限修饰符：默认修饰符，`public`
    * 状态修饰符：`final`
    * 抽象修饰符：`abstract`
    
    * 用的最多的就是：`public`
    
* C:成员变量：
    * 权限修饰符：`private`，默认的，`protected`，`public`
    * 状态修饰符：`static`，`final`
    
    * 用的最多的就是：`private`
    
* D:构造方法：
    * 权限修饰符：`private`，默认的，`protected`，`public`
    
    * 用的最多的就是：`public`
    
* E:成员方法：
    * 权限修饰符：`private`，默认的，`protected`，`public`
    * 状态修饰符：`static`，`final`
    * 抽象修饰符：`abstract`
    
    * 用的最多的就是：`public`
    
* F:除此以外的组合规则：
    * 成员变量：`public static final`
    * 成员方法：
        * `public static` 
        * `public abstract`
        * `public final`

###10.08_面向对象(内部类概述和访问特点)(了解)
* A:内部类概述
* B:内部类访问特点
    * a:内部类可以直接访问外部类的成员，包括私有。
    * b:外部类要访问内部类的成员，必须创建对象。
    * 外部类名.内部类名 对象名 = 外部类对象.内部类对象;

```Java
class Outer {  //外部类
    private int num = 10 ;
    
    class Inner { //内部类
        public void method() {
            System.out.println("我是内部类，我能访问外部类私有成员.."+num);
        }
    }
}

// 运行代码
Outer.Inner oi = new Outer().new Inner();
oi.method();
```
    
###10.09_面向对象(成员内部类私有使用)(了解)

 ```Java
class Outer { //外部类
    private class Inner { //私有内部类
        public void method() {
            System.out.println("我是内部类，我能访问外部类私有成员..");
        }
    }

    // 通过方法，访问内部私有类
    public void print() {
        Inner in = new Inner();
        in.method();
    }
}
```
###10.10_面向对象(静态成员内部类)(了解)

```Java
class Outer { //外部类
    static class Inner { //静态内部类
        public void method() {
            System.out.println("我是静态内部类");
        }
    }
}

// 运行代码
// 访问方式： 外部类名.内部类名 对象名 = 外部类名.内部类对象;
Outer.Inner oi = new Outer.Inner();
oi.method();

```


###10.11_面向对象(成员内部类的面试题)(掌握)

 ```Java
// 要求：使用已知的变量，在控制台输出30，20，10。
class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(???);  // num
            System.out.println(???);  // this.num
            System.out.println(???);  // Outer.this.num
        }
    }
}

// 运行代码：
new Outer().new Inner().show();

// 内部类之所以能访问到外部类的成员，是因为它能获取到
// 外部类的引用 ： 外部类名.this

```

###10.12_面向对象(局部内部类访问局部变量的问题)(掌握)

* 局部内部类访问局部变量必须用`final`修饰
* 局部内部类在访问他所在方法中的局部变量必须用`final`修饰,为什么?
    - 因为当调用这个方法时,局部变量如果没有用`final`修饰,他的生命周期和方法的生命周期是一样的,
    - 当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,
    - 就没有了,如果用`final`修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
* 但是jdk1.8取消了这个事情,所以我认为这是个bug

```Java
class Outer { //外部类
    
    public void method() {
       final int num = 10 ;

        class Inner { //局部内部类
            public void print() {
                System.out.println("我是局部内部类.." + num);
            }
        }
        
        Inner in = new Inner();
        in.print();
    }
}
```
###10.13_面向对象(匿名内部类的格式和理解)
* A:匿名内部类
    * 就是内部类的简化写法。
* B:前提：存在一个类或者接口
    * 这里的类可以是**具体类**也可以是**抽象类**。
* C:格式：
* 
        new 类名或者接口名(){
            重写方法;
        }
* D:本质是什么呢?
    * 是一个继承了该类或者实现了该接口的子类匿名对象。

```Java
interface Protocol {
    public abstract void print();
}

class Outer {
    class Inner implements Protocol {
        public void print() {
            System.out.println("有名内部类实现接口");
        }
    }

    // 匿名内部类的实现接口的方式
    public void method() {
        new Protocol()  {  // 实现Protocol接口,这样不用多态的方式，只适合实现一个方法，调用一个方法
            public void print() {
                System.out.println("匿名类实现接口");
            }
        }.print(); // 这个分号不能少
    }
}
```

###10.15_面向对象(匿名内部类在开发中的应用)

* A:代码如下
* 
        //这里写抽象类，接口都行
        abstract class Person {
            public abstract void show();
        }
    
        class PersonDemo {
            public void method(Person p) {
                p.show();
            }
        }
    
        class PersonTest {
            public static void main(String[] args) {
                //如何调用PersonDemo中的method方法呢?
                PersonDemo pd = new PersonDemo ();
                
            }
        }

###10.16_面向对象(匿名内部类的面试题)

```Java
// 要求在控制台输出”HelloWorld”
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show(); //链式编程，调用方法之后，接着调用方法
    }
}

// 陷阱一：interface里面的方法都是 public abstract 的，实现时，如果不是public，就会报错
// 陷阱二: 类名.方法名(), 这种调用方法的方法，必须是 public static修饰的
// 答案：
class Outer { 
    //补齐代码 
    public static Inter method() {
        return new Inter(){
                    public void show() {
                        System.out.println("xxoo");
                    }
                };
    }
}
```

*END。*
*我是小侯爷。*
*在魔都艰苦奋斗，白天是上班族，晚上是知识服务工作者。*
*如果读完觉得有收获的话，记得关注和点赞哦。*
*非要打赏的话，我也是不会拒绝的。*