J-11 面向对象

链式编程；
包；
权限修饰符；
内部类；

链式编程：每次调用完毕后，返回的是一个对象。

二十二、包

包的概述

包，即文件夹。

作用
① 吧相同的类名放到不同的包中
② 对类进行分类管理
格式
```
  package 包名；
```

多级包用，分开即可。

注意事项：
package语句必须是程序的第一条可执行的代码；
package语句在一个java文件中只能有一个；
如果没有package，默认表示无包名。

带包的类的编译和运行

手动式

javac 命令编译该java文件
```
  javac HelloWorld.java
```
手动创建包名
将第一步产生的.class文件放到最底层包
回到和包根目录在同一目录的地方，然后带包运行。
```
  java cn.itcast.HelloWorld
```

自动式

javac编译时加上-d
```
  javac -d . HelloWorld.java
```
带包运行
```
  java cn.itcast.HelloWorld
```

不同包下类之间的访问

不导包

	//Demo.java
	package com.liuyi;
	
	public class Demo {
		public int sum(int a,int b) {
			return a + b;
		}
	}
	
	//Test.java
	package cn.itcast;
	class Test {
		public static void main(String[] args) {
			Demo d = new Demo();
		
			com.liuyi.Demo d = new com.liuyi.Demo();
			System.out.println(d.sum(10,20));
			
		}
	}

导包

格式：
```
  import 包名；
```
注意事项
- 导入到类的名称。
- 虽然可以最后写*，但是不建议。

package，import，class的顺序关系

package > import > class

package：只能有一个
import：可以有多个
class：可以有多个，以后建议是一个

二十三、修饰符

权限修饰符

	本类中	同一个包下（子类、无关类）	不同包下（子类）	不同包下（无关类）
private	Y	N	N	N
默认	Y	Y	N	N
protected	Y	Y	Y	N
public	Y	Y	Y	Y

修饰符小结

小结
权限修饰符：private，默认，protected，public
状态修饰符：static，final
抽象修饰符：abstract
类：
权限：默认，public
状态：final
抽象：abstract
成员变量：
权限：private，默认，protected，public
状态：static，final
构造方法：
权限：private，默认，protected，public
成员方法：
权限修饰符：private，默认，protected，public
状态修饰符：static，final
抽象修饰符：abstract
除此以外的组合规则：
成员变量：public static final
成员方法：
public static
public abstract
public final

二十四、内部类

概述

定义：
把类定义在其他类的内部，这个类就被称为内部类。
访问特点：
内部类可以访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。
注意事项：
①内部类与外部类没有继承关系。
②通过外部类名限定this对象。Outer.this
分类：
- 成员位置：
  成员内部类（一般不让外部类直接访问。）
```
  外部类名.内部类名 对象名 = 外部类对象.内部类对象;
  Outer.Inner oi = new Outer().new Inner();
```
成员内部类的修饰符：
private 为了保证数据的安全性

static 为了方便访问数据。
内部类用静态修饰，是因为内部类可以视为外部类的成员。
被静态修饰的成员内部职能访问外部类的静态成员。
成员内部类被静态修饰后的访问方式：
```
  外部类名.内部类名 对象名 = new 外部类名.内部类对象；
  Outer.Inner oi = new Outer.Inner();
```
- 局部位置：
  局部内部类
  可以直接访问外部类成员；在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用内部类功能。
  注意事项：
  局部内部类访问局部变量必须用final修饰。
  why：因为局部变量随着方法调用而调用，随着调用完毕而消失；而堆内存的内容并不会立即消失，所以我们加final修饰，变量成为常量。

匿名内部类

安卓中应用广泛

即内部类的简化写法。
前提：存在一个类或者接口。

格式：

  new 类名或者接口名（）{
  	重写方法；
  }；

本质：是一个继承了该类或者是实现了该接口的子类匿名对象。

实例：

  interface Inter {
  	public abstract void show();
  	public abstract void show2();
  }
  
  class Outer {
  	public void method() {
  		//一个方法的时候
  		/*
  		new Inter() {
  			public void show() {
  				System.out.println("show");
  			}
  		}.show();
  		*/
  		
  		//二个方法的时候
  		/*
  		new Inter() {
  			public void show() {
  				System.out.println("show");
  			}
  			
  			public void show2() {
  				System.out.println("show2");
  			}
  		}.show();
  		
  		new Inter() {
  			public void show() {
  				System.out.println("show");
  			}
  			
  			public void show2() {
  				System.out.println("show2");
  			}
  		}.show2();
  		*/
  		
  		//如果我是很多个方法，就很麻烦了
  		//那么，我们有没有改进的方案呢?
  		Inter i = new Inter() { //多态
  			public void show() {
  				System.out.println("show");
  			}
  			
  			public void show2() {
  				System.out.println("show2");
  			}
  		};
  		
  		i.show();
  		i.show2();
  	}
  }
  
  class InnerClassDemo6 {
  	public static void main(String[] args) {
  		Outer o = new Outer();
  		o.method();
  	}
  }