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