java基础学习_面向对象(下)03_day10总结

=============================================================================
=============================================================================
涉及的知识点有：
　　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 }

=============================================================================