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 }

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