=============================================================================
=============================================================================
涉及的知识点有：
1：方法的形式参数和方法的返回值的问题(理解)
(1)方法的形式参数为引用数据类型
(2)方法的返回值类型为引用数据类型
(3)链式编程
2：包(理解)
(1)包其实就是文件夹。
(2)包的作用
(3)包的定义(掌握)
(4)包的注意事项(掌握)
(5)带包的编译和运行
(6)Java中不同包下的类与类之间的访问
3：导包(掌握)
(1)导包的原因
(2)导包的格式
(3)package,import,class有没有顺序关系呢？
4：权限修饰符(掌握)
(1)权限修饰符的权限测试
(2)这四种权限修饰符在任意时刻只能出现一种。
5：类及其组成所使用的常见修饰符(理解)
(1)修饰符的分类
(2)常见的类及其组成所使用的修饰符
1.修饰类的
2.修饰成员变量的
3.修饰构造方法的
4.修饰成员方法的
(3)另外比较常见的修饰符组合规则
6:内部类(理解)
(1)把类定义在另一个类的内部，该类就被称为内部类。
(2)内部类的访问特点
(3)内部类的分类(内部类的位置)
(4)成员内部类
(5)成员内部类的面试题(填空)
(6)局部内部类
(7)匿名内部类(很重要掌握)
(8)匿名内部类在开发中的使用
(9)匿名内部类的面试题(补齐代码)
=============================================================================
=============================================================================
1：方法的形式参数和方法的返回值的问题(理解)
(1)方法的形式参数为引用数据类型：
1.方法的形式参数为类名时：需要该类的对象。(匿名对象的时候已经讲过了)
2.方法的形式参数为抽象类名时：需要该抽象类的子类对象。
3.方法的形式参数为接口名时：需要该接口的实现类对象。
(2)方法的返回值类型为引用数据类型：
1.方法的返回值类型为类名时：返回的是该类的对象。
2.方法的返回值类型为抽象类名时：返回的是该类的子类对象。
3.方法的返回值类型为接口名时：返回的是该接口的实现类的对象。
(3)链式编程
对象.方法1().方法2().方法3(). ……… .方法n();
这种用法：
其实
在方法1()调用完毕后，应该一个对象；
方法2()调用完毕后，应该返回一个对象。
方法3()调用完毕后，应该返回一个对象。
…………
方法n()调用完毕后，返回的可能是对象，也可以不是对象。
-----------------------------------------------------------------------------
2：包(理解)
(1)包其实就是文件夹。
(2)包的作用：
A:区分同名的类(即把具有相同类名的类放到不同的包中)。
B:对类进行分类管理。
a:包按照功能分
cn.itcast.add 增加功能的包
AddStudent 增加学生的类
AddTeacher 增加老师的类
cn.itcast.delete 删除功能的包
DeleteStudent 删除学生的类
DeleteTeacher 删除老师的类
cn.itcast.update 修改功能的包
UpdateStudent 修改学生的类
UpdateTeacher 修改老师的类
cn.itcast.find 查找功能的包
FindStudent 查找学生的类
FindTeacher 查找老师的类
b:包按照模块分
cn.itcast.student 学生的包
AddStudent 增加学生的类
DeleteStudent 删除学生的类
UpdateStudent 修改学生的类
FindStudent 查找学生的类
cn.itcast.teacher 老师的包
AddTeacher 增加老师的类
DeleteTeacher 删除老师的类
UpdateTeacher 修改老师的类
FindTeacher 查找老师的类
小结：开发中，两种分类方式结合使用。
---------------------------------------
(3)包的定义(掌握)
定义包的格式：
package 包名;
多级包用.分开。
(4)包的注意事项(掌握)：
A:package语句必须是程序的第一条可执行的代码。(可执行=可被虚拟机识别)
B:package语句在一个java文件中只能有一个。
C:如果没有package，默认表示无包名。
---------------------------------------
(5)带包的编译和运行
A:手动式
a:编写一个带包的Xxx.java文件。
例如：
package cn.itcast;
class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}
b:通过javac命令编译该Xxx.java文件，生成对应的Xxx.class文件。
c:手动创建包名。
d:把b步骤的Xxx.class文件放到c步骤的最底层包。
e:回到和包根目录在同一目录的地方，然后带包运行。
格式：java cn.itcast.Xxx
---------------------------------------
B:自动式(掌握)
a:编写一个带包的Xxx.java文件。
b:javac编译的时候带上-d即可
格式：javac -d . Xxx.java
c:回到和包根目录在同一目录的地方，然后带包运行
格式：java cn.itcast.Xxx
---------------------------------------
(6)Java中不同包下的类与类之间的访问
-----------------------------------------------------------------------------
3：导包(掌握)
(1)导包的原因：我们多次使用一个带包的类，都需要加包的全路径非常的麻烦，这个时候，Java就提供了导包的功能，提供了一个关键字import。
(2)导包的格式：
java.lang不需要导入
import xxx.yyy.类名;
这种方式导入的是：导入到类的级别。
另一种：
import xxx.yyy.*;(不建议)
(3)package,import,class有没有顺序关系呢？
有。
package > import > class
package:只能有一个
import:可以有多个
class:可以有多个，以后建议是一个。(因为每一个类是一个独立的单元)
-----------------------------------------------------------------------------
4：权限修饰符(掌握)
(1)权限修饰符的权限测试
小结：protected修饰的东西其实就是给子类用的。
所以以后在设计父类的时候，可以把private修饰的成员变量用protected修饰，
这样子类中就可以使用this关键字了，比如：this.name = name;
但是其实这样的做法不是很多，还是建议用private修饰最好。
---------------------------------------
(2)这四种权限修饰符在任意时刻只能出现一种。
public class Demo {}
-----------------------------------------------------------------------------
5：类及其组成所使用的常见修饰符(理解)
(1)修饰符的分类：
权限修饰符：private、默认、protected、public
状态修饰符：static、final
抽象修饰符：abstract
(2)常见的类及其组成所使用的修饰符：
1.修饰类的：
有：默认、public、final、abstract
示例如下：
class Demo {} //默认修饰符
public class Demo {}
final class Demo {} //最终类，不能被继承。
abstract class Demo {} //抽象类
常用类的修饰符：public class Demo {}
特别注意：静态不可以修饰外部类，但是可以修饰内部类。
---------------------------------------
2.修饰成员变量的：
有：private、默认、protected、public、static、final
示例如下：
private int x = 10;
int y = 20;
protected int z = 30;
public int a = 40;
public final int b = 50; //表示自定义的常量
public static int c = 60; //表示定义的通过类名访问的变量
public static final int d = 70; //表示自定义的通过类名访问的常量
常用成员变量的修饰符：private int x = 10;
---------------------------------------
3.修饰构造方法的：
有：private、默认、protected、public
示例如下：
private Demo(){}
Demo(String name){}
protected Demo(String name, int age) {}
public Demo(String name, int age, String address) {}
常用构造方法的修饰符：public Demo(String name, int age, String address) {}
小结：构造方法只能使用权限修饰符，即构造方法只提供访问权限，不提供其他的。
---------------------------------------
4.修饰成员方法的：
有：private、默认、protected、public、static、final、abstract
示例如下：
private void show() {}
void show() {}
protected void show() {}
public void show() {}
static void show() {} //静态方法，只能通过类名访问
abstract void show(); //抽象方法
final void show() {} //最终方法
常用成员方法的修饰符：public void show() {}
---------------------------------------
(3)另外比较常见的修饰符组合规则：
示例如下：
修饰成员变量的：
public static final int x = 10; //定义一个静态的最终变量(常量)，只能通过类名访问
修饰成员方法的：
public static void show() {}
public abstract void show();
public final void show() {}
-----------------------------------------------------------------------------
6:内部类(理解)
(1)把类定义在另一个类的内部，该类就被称为内部类。
举例：把类B定义在类A中，类B就被称为内部类。
(2)内部类的访问特点：
A:内部类可以直接访问外部类的成员，包括私有成员。
B:外部类要想访问内部类成员，必须创建内部类的对象，通过内部类的对象去访问。
(3)内部类的分类(内部类的位置)：
A:成员位置:在类中的成员位置定义的类，被称为成员内部类。
B:局部位置:在类中的局部位置定义的类，被称为局部内部类。
---------------------------------------
(4)成员内部类
成员内部类的常见修饰符及应用
A:private 为了保证数据的安全性
B:static 为了方便访问数据
注意：静态的内部类访问外部类的数据时，外部类的数据必须用静态修饰。
成员内部类不被静态修饰后的访问格式是:
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
成员内部类被静态修饰后的访问格式是:
外部类名.内部类名 对象名 = new 外部类名.内部类名();
---------------------------------------
(5)成员内部类的面试题(填空)
注意：
1:内部类和外部类没有继承关系。(这样你就不会使用super去访问外部类的成员变量了)
2:通过外部类名限定this对象。
Outer.this
1 class Outer {
2 public int num = 10;
3
4 class Inner {
5 public int num = 20;
6
7 public viod show() {
8 int num = 30;
9
10 System.out.println(num); //30
11 System.out.println(this.num); //20
12 System.out.println(Outer.this.num); //10 通过外部类名限定this对象。
13 System.out.println(new Outer().num);//10 通过创建外部类对象，来调用外部类的成员变量。
14 }
15 }
16 }
17 class InnerClassTest {
18 public static void main(String[] args) {
19 Outer.Inner oi = new Outer().new Inner();
20 oi.show();
21 }
22 }
---------------------------------------
(6)局部内部类
A:局部内部类可以直接访问外部类的成员。
B:局部内部类在局部位置可以创建内部类对象，通过内部类对象调用内部类方法，来使用局部内部类功能。
C:局部内部类访问局部变量，局部变量必须加final修饰。为什么呢？
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，
局部对象还要使用这个局部变量。为了让数据还能继续被使用，就用fianl修饰局部变量，
这样，在堆内存里面存储的其实是一个常量值。通过反编译工具可以看一下。
通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是局部变量名。
---------------------------------------
(7)匿名内部类(很重要掌握)
A:匿名内部类是局部内部类的简化形式。
B:匿名内部类的前提：
存在一个类或者接口。
这里的类可以是具体类也可以是抽象类。
C:格式:
new 类名或者接口名() {
重写方法;
}
D: 匿名内部类的本质是什么呢？
答：是一个继承了该类的子类或者实现了该接口的实现类的匿名对象。
简言之：匿名内部类是一个子类的匿名对象。
再简言之：匿名内部类是子类的对象。
小结：匿名内部类是一个结合体，是子类和对象的结合体。
---------------------------------------
(8)匿名内部类在开发中的使用
我们在开发的时候，会看到抽象类，或者接口作为方法的形式参数。
而这个时候，我们知道实际需要的是一个子类的对象。
如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式进行简化。
Android开发中这种格式见得多，
JavaEE开发中见得少。
为什么呢？
因为匿名内部类的好处是：
匿名内部类用完之后就是垃圾(即只能用一次)，就可以立即被垃圾回收器回收，
栈内存没有东西指向你，Android的手机内存小，要及时让这个对象被回收。
1 interface Person {
2 public abstract void study();
3 }
4
5 class PersonDemo {
6 public void method(Person p) {
7 p.study();
8 }
9 }
10
11 class PersonTest {
12 public static void main(String[] args) {
13 PersonDemo pd = new PersonDemo();
14 pd.method(new Person() {
15 public void study() {
16 System.out.println("好好学习，天天向上");
17 }
18 });
19 }
20 }
---------------------------------------
(9)匿名内部类的面试题(补齐代码)
1 interface Inter {
2 void show();
3 }
4
5 class Outer {
6 //补齐代码
7 public static Inter method() {
8 return new Inter() {
9 public void show() {
10 System.out.println("HelloWorld");
11 }
12 };
13 }
14 }
15
16 class OuterDemo {
17 public static void main(String[] args) {
18 Outer.method().show(); //"HelloWorld"
19 }
20 /*
21 1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
22 2:Outer.method().show()可以看出method()方法的返回值是一个对象。
23 又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
24 */
25 }
=============================================================================