diff --git a/MyNote b/MyNote new file mode 100644 index 00000000..0cc9a4ae --- /dev/null +++ b/MyNote @@ -0,0 +1,4 @@ +1.java输入输出流的基础是InputStream和OutputStream，最主要的方法是 abstract int read（） 和 abstract int write（） +其他子类在继承胡都要重写覆盖这两个方法。 +read和write方法在执行时都将阻塞，直至字节被读入或是写出 这就意味着如果流不被立即访问（通常是由于网络连接忙），那么当前线程将被阻塞 +这使得这两个方法等待指定的流变为可用阶段，其他线程将有机会去执行有用的工作。 diff --git "a/day09/code/01_\345\244\232\346\200\201/DuoTaiDemo.java" "b/day09/code/01_\345\244\232\346\200\201/DuoTaiDemo.java" index 0f0d197e..b3551198 100644 --- "a/day09/code/01_\345\244\232\346\200\201/DuoTaiDemo.java" +++ "b/day09/code/01_\345\244\232\346\200\201/DuoTaiDemo.java" @@ -1,10 +1,10 @@ /* - ̬ĺô - A:˳ά(ɼ̳б֤) - B:˳չ(ɶ̬֤) + 多态的好处： + A:提高了程序的维护性(由继承保证) + B:提高了程序的扩展性(由多态保证) - ̬ı׶ˣ - ܷеĹܡ + 多态的弊端： + 不能访问子类特有的功能。 */ class Animal { public void eat(){} @@ -12,72 +12,72 @@ public void sport(){} /* public void sleep() { - System.out.println("˯"); + System.out.println("爱睡觉"); } */ } - +//（继承）重写Animal类里的2个成员函数（方法） class Dog extends Animal { public void eat(){ - System.out.println(""); + System.out.println("狗吃肉"); } public void sport(){ - System.out.println("ܲ"); + System.out.println("狗跑步"); } - + //作为子类可以新加方法 public void lookDoor() { - System.out.println(""); + System.out.println("看门"); } } class Cat extends Animal { public void eat(){ - System.out.println("è"); + System.out.println("猫吃鱼"); } public void sport(){ - System.out.println("è׽Բ"); + System.out.println("猫和老鼠捉迷藏"); } } class Pig extends Animal { public void eat(){ - System.out.println(""); + System.out.println("猪吃饲料"); } public void sport(){ - System.out.println("˯"); + System.out.println("猪爱睡觉"); } } class DuoTaiDemo { public static void main(String[] args) { /* - //ϲһֻ + //我喜欢狗，养了一只狗 Dog d = new Dog(); d.eat(); d.sport(); - //Һϲһֻ + //我很喜欢狗，又养了一只狗 Dog d2 = new Dog(); d2.eat(); d2.sport(); - //رϲһֻ + //我特别喜欢狗，又养了一只狗 Dog d3 = new Dog(); d3.eat(); d3.sport(); */ - //... - //ҪֻܶңÿҪһЩ߻ҪһЩ - //Щһġǹһ - //һֱдȥ÷dz鷳 - //ԣҪǶŻ - //Ż?ΪֲһģǶһ - //ԣǾ׼ʹ÷ĽѶΪݹɡ - //˷ǾͿµ + //我... + //我要养很多只狗，而且，每个狗对象都要调用一些方法，或者还要做一些操作。 + //并且这些操作是一样的。仅仅是狗对象不一样。 + //如果一直写下去，代码会变得非常麻烦 + //所以，我们要考虑对这个代码进行优化 + //如何优化呢?因为发现操作是一样的，就是对象不一样 + //所以，我们就准备使用方法改进，把对象作为参数传递过来即可。 + //有了方法后，我们就可以如下调用 Dog d = new Dog(); Dog d2 = new Dog(); Dog d3 = new Dog(); @@ -90,10 +90,10 @@ public static void main(String[] args) { printAnimal(d3); System.out.println("-----------"); - //ϲèϲèرϲè + //我喜欢猫，很喜欢猫，特别喜欢猫 //... - //дһʵְ - // + //写一个方法实现吧 + //调用 Cat c = new Cat(); Cat c2 = new Cat(); Cat c3 = new Cat(); @@ -106,10 +106,10 @@ public static void main(String[] args) { printAnimal(c3); System.out.println("-----------"); - //ҺһֻҪдһĴ룬ʵ? - //A:ȴ̳Զ - //B:ڲдʵ - //C:ڲд󣬵÷ + //我后来养了一只猪，请问我要写成一样的代码，该如何实现呢? + //A:先创建猪类继承自动物类 + //B:在测试类里面写方法实现 + //C:在测试类中创建对象，调用方法即可 Pig p = new Pig(); Pig p2 = new Pig(); Pig p3 = new Pig(); @@ -121,16 +121,16 @@ public static void main(String[] args) { printAnimal(p2); printAnimal(p3); - //һϲǣҪ - //ղһ,ԼҲǿɵ - //һϲӣ... - //һ£ - //¶һµûκģǼڲеmainеҲû - //DzӦȥڲµĹ - //Ժдһʱһԭ򣺶չţ޸Ĺرա - //ǣҪ򣬻͵ȥ޸IJ - //Ϊ˲ȥ޸IJгmain - //Ҫļһ + //我还喜欢狼，要养狼 + //步骤会跟刚才一样,我们自己也是可以完成的 + //我还喜欢猴子，... + //我们来分析一下： + //我们重新定义一个新的类是没有任何问题的，我们继续在测试类中的main方法中调用也是没有问题的 + //我们不应该去在测试类中添加新的功能 + //以后，我们再写一个程序的时候，有一个基本的设计原则：对扩展开放，对修改关闭。 + //但是，我们现在如果要完成这个程序，还就得去修改测试类 + //为了不去修改测试类中除了main方法以外的内容 + //我们需要对下面的几个方法进行一个分析： } /* @@ -159,4 +159,4 @@ public static void printPig(Pig p) { //a.lookDoor(); a.sport(); } -} \ No newline at end of file +} diff --git "a/day09/code/01_\345\244\232\346\200\201/DuoTaiDemo2.java" "b/day09/code/01_\345\244\232\346\200\201/DuoTaiDemo2.java" index 7b33e6d7..c804840f 100644 --- "a/day09/code/01_\345\244\232\346\200\201/DuoTaiDemo2.java" +++ "b/day09/code/01_\345\244\232\346\200\201/DuoTaiDemo2.java" @@ -1,31 +1,32 @@ /* - ηй? - A:󼴿ɡ - B:̬ת - ת - ӵ - ָ - ת - Ӹ - תΪ + 如何访问子类特有功能呢? + A:创建子类对象即可。 + B:多态的转型问题 + 向上转型 + 从子到父 + 父类引用指向子类对象 + 向下转型 + 从父到子 + 父类引用转为子类对象 - װ + 孔子装爹案例 - ӣ():,Ϸ():,age:20 - ӵ():JavaSEage:40 + 孔子：教书():讲论语,玩游戏():连连看,age:20 + 孔子爹：教书():JavaSE，age:40 - //̬ - ӵ k = new (); //Androidܻ𣬶JavaSEAndroidJavaSEܻ - //̫æװȥΡճСӣ۾ת - System.out.println(k.age); //40 - k.(); // - //k.Ϸ(); // + //多态 + 孔子爹 k爹 = new 孔子(); //Android很火，而JavaSE是Android基础，所以JavaSE很火。 + //爹太忙，儿子装爹去讲课。粘上小胡子，带上眼镜。向上转型 + // k爹 是一个句柄实际只想的是一个new出的“儿子”对象 + System.out.println(k爹.age); //40 + k爹.教书(); //讲论语 + //k爹.玩游戏(); //报错 - //ؼ - k = ()k; //ȥСӣȥ۾ת + //回家了 + 孔子 k = (孔子)k爹; //去掉小胡子，去掉眼镜。向下转型 //强制转换类型 System.out.println(k.age); //20 - k.(); // - k.Ϸ(); + k.教书(); //讲论语 + k.玩游戏(); */ class Animal { public void eat(){} @@ -33,35 +34,35 @@ public void eat(){} class Dog extends Animal { public void eat(){ - System.out.println("Թͷ"); + System.out.println("狗吃骨头"); } public void help() { - System.out.println("԰ץС͵"); + System.out.println("狗可以帮助警察叔叔抓小偷"); } } class Cat extends Animal { public void eat(){ - System.out.println("è"); + System.out.println("猫吃老鼠"); } } class DuoTaiDemo2 { public static void main(String[] args) { - //̬ - Animal a = new Dog(); //ת + //多态 + Animal a = new Dog(); //向上转型 a.eat(); - //a.help(); //뿴 + //a.help(); //编译看左边 - //ת + //向下转型 Dog d = (Dog)a; d.eat(); d.help(); System.out.println("-------------"); - //ᱨ? - a = new Cat(); ////ת + //会报错吗? + a = new Cat(); ////向上转型 a.eat(); Cat c = (Cat)a; @@ -71,4 +72,4 @@ public static void main(String[] args) { //dd.eat(); //dd.help(); } -} \ No newline at end of file +} diff --git "a/day09/day09\346\200\273\347\273\223.txt" "b/day09/day09\346\200\273\347\273\223.txt" index 3f10c6a7..b1f7df2a 100644 --- "a/day09/day09\346\200\273\347\273\223.txt" +++ "b/day09/day09\346\200\273\347\273\223.txt" @@ -1,102 +1,102 @@ -1̬() - (1)ͬһڲͬʱֳֵ̱Ķ״̬ - ˮèͶ - (2)ǰ - A:м̳лʵֹϵ - B:зд - Ϊеij󷽷Լӿеķ뱻дò塣 - C:и߸ӿָ - (3)̬еijԱص +1：多态(掌握) + (1)同一个事物在不同时刻表现出现的多种状态。 + 举例：水，猫和动物 + (2)前提 + A:有继承或者实现关系 + B:有方法重写 + 因为抽象类中的抽象方法以及接口中的方法都必须被子类重写，调用才有意义。 + C:有父类或者父接口引用指向子类对象 + (3)多态中的成员访问特点 Fu f = new Zi(); - A:Ա - 뿴ߣп - B:Ա - 뿴ߣпұ - C:̬ - 뿴ߣп - (4)ôͱ׶ - A:ô - ˴ά - ˴չ - B:׶ - ܷй - (5)ηй - A: - B:ת - (6)̬еת - A:ת - ӵ - B:ת - (ǿת) - (7)װ + A:成员变量 + 编译看左边，运行看左边 // f句柄实际指向一个ZI（）类型的对象 + B:成员方法 + 编译看左边，运行看右边 + C:静态方法 + 编译看左边，运行看左边 + (4)好处和弊端 + A:好处 + 提高了代码的维护性 + 提高了代码的扩展性 + B:弊端 + 不能访问子类特有功能 + (5)如何访问子类特有功能 + A:创建子类对象 + B:向下转型 + (6)多态中的转型 + A:向上转型 + 子到父 + B:向下转型 + 父到子(加强制转换) + (7)孔子装爹案例 -2() - (1)ЩʱǶﲻþĶʱӦðﶨΪࡣ - (2)ص㣺 - A:߳󷽷abstract - B:вһг󷽷г󷽷һdz - C:಻ʵ - ԰ն̬ķʽʵ - D: - a:Ҫôdz - b:Ҫôдег󷽷 - (3)ijԱص㣺 - A:Ա - DZҲdz - B:췽 - С - ʵй췽ʲô? - ʸݵijʼ - C:Ա - dzģҲǷdz - (4)İ - A:è - B:ʦ - C:ѧ - D:Ա - (5)С - A:㿴һоȻûг󷽷,? - ñ˴ - B:abstractܺЩؼֹ? - a:private ͻ - b:final ͻ - c:static +2：抽象类(掌握) + (1)有些时候，我们对事物不能用具体的东西来描述，这个时候就应该把事物定义为抽象类。 + (2)抽象类的特点： + A:抽象类或者抽象方法必须用abstract修饰 + B:抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类 + C:抽象类不能实例化 + 可以按照多态的方式实例化。 + D:抽象类的子类 + a:要么是抽象类 + b:要么重写抽象类中的所有抽象方法 + (3)抽象类的成员特点： + A:成员变量 + 可以是变量，也可以是常量 + B:构造方法 + 有。 + 不能实例化，有构造方法有什么意义呢? + 用于子类访问父类数据的初始化。 + C:成员方法 + 可以是抽象的，也可以是非抽象的 + (4)抽象类的案例 + A:猫狗案例 + B:老师案例 + C:学生案例 + D:员工案例 + (5)两个小问题 + A:如果你看到一个抽象类中居然没有抽象方法,这个抽象类的意义何在? + 不让别人创建 + B:abstract不能和哪些关键字共存? + a:private 冲突 + b:final 冲突 + c:static 无意义 -3ӿ() - (1)Щʱ򣬲ﱾ߱ĹܣǾͿʹýӿչ - (2)ӿڵص㣺 - A:ӿùؼinterface - ʽǣinterface ӿ {} - B:ʵֽӿùؼimplements - ʽǣclass implements ӿ {} - C:ӿڲʵ - D:ӿڵ - a:Ҫôdz - b:Ҫôдӿез - (3)ӿڵijԱص - A:Ա - ֻdz - Ĭηpublic static final - B:Ա - ֻdz󷽷 - Ĭηpublic abstract - Ƽ - Լдӿڵʱ򣬰Ĭηϡ - (4)ӿڵĹϵ - A: - ̳йϵֻ̳ܵУԶ̳С - B:ӿ - ʵֹϵԵʵ֣ҲԶʵ֡ - ڼ̳һͬʱʵֶӿڡ - C:ӿӿ - ̳йϵԵ̳УҲԶ̳С - (5)ͽӿڵ? - A:Ա - B:ϵ - C: - ࣺ࣬涨ǹݡ - ӿڣӿڣ涨չݡ - (6)ӿڵİ - A:è - B:ʦѧ - C:˶ԱѧӢ \ No newline at end of file +3：接口(掌握) + (1)有些时候，不是事物本身具备的功能，我们就考虑使用接口来扩展。 + (2)接口的特点： + A:定义接口用关键字interface + 格式是：interface 接口名 {} + B:类实现接口用关键字implements + 格式是：class 类名 implements 接口名 {} + C:接口不能实例化 + D:接口的子类 + a:要么是抽象类 + b:要么重写接口中的所有方法 + (3)接口的成员特点 + A:成员变量 + 只能是常量。 + 默认修饰符：public static final + B:成员方法 + 只能是抽象方法，交由实现接口的类实现该方法。 + 默认修饰符：public abstract + 推荐： + 建议自己写接口的时候，把默认修饰符加上。 + (4)类与接口的关系 + A:类与类 + 继承关系，只能单继承，可以多层继承。 + B:类与接口 + 实现关系，可以单实现，也可以多实现。 + 还可以在继承一个类的同时实现多个接口。 + C:接口与接口 + 继承关系，可以单继承，也可以多继承。 + (5)抽象类和接口的区别? + A:成员区别 + B:关系区别 + C:设计理念区别 + 抽象类：父抽象类，里面定义的是共性内容。 + 接口：父接口，里面定义的是扩展内容。 + (6)接口的案例： + A:猫狗案例加入跳高 + B:老师和学生案例加入抽烟 + C:教练和运动员案例加入学英语 diff --git "a/day10/day10\346\200\273\347\273\223.txt" "b/day10/day10\346\200\273\347\273\223.txt" index 2dff50f4..64707f3e 100644 --- "a/day10/day10\346\200\273\347\273\223.txt" +++ "b/day10/day10\346\200\273\347\273\223.txt" @@ -1,84 +1,84 @@ -1ʽͷֵ() - (1)ʽ - ͣҪǶӦֵ - ͣ - ࣺĶ - ࣺ - ӿڣýӿڵʵ - (2)ֵ⣺ - ͣصǶӦֵ - ͣ - ࣺĶ - ࣺ - ӿڣýӿڵʵ - (3)ʽ +1：形式参数和返回值问题(掌握) + (1)形式参数： + 基本类型：需要的是对应的值 + 引用类型： + 类：该类的对象 + 抽象类：该类的子类对象 + 接口：该接口的实现类对象 + (2)返回值问题： + 基本类型：返回的是对应的值 + 引用类型： + 类：该类的对象 + 抽象类：该类的子类对象 + 接口：该接口的实现类对象 + (3)链式编程 new A().b().c().d(); -2() - (1)ʵļ - (2)з - (3)ʽ - package ; - (4)ע - A:packagedzеĵһִ - B:packageΨһ - C:ûpackageĬް - (5)ı +2：包(理解) + (1)其实就是文件夹 + (2)对类进行分类管理 + (3)格式： + package 包名; + (4)注意事项 + A:package是程序中的第一条可执行语句 + B:在类中package是唯一的 + C:没有package，默认是无包名 + (5)带包的类的编译和运行 -3() - (1)Ϊ˷ʹòͬµ࣬Ҫ - (2)ʽ - import ....; +3：导包(理解) + (1)为了方便使用不同包下的类，需要导包 + (2)格式： + import 包名.报名...类名; - ע⣺Ե뵽*,Dz - (3)packageimportclassû˳ϵ? - С + 注意：可以导入到*,但是不建议 + (3)package，import，class在类中有没有顺序关系呢? + 有。 package --> import --> class -4η() - (1)4Ȩη - ͬһ ͬµ ͬµ +4：修饰符(理解) + (1)4种权限修饰符 //最常用的是private类型和public类型，重点是子类的继承性 + 本类 同一个包下 不同包下的子类 不同包下的其他类 private Y - Ĭ Y Y + 默认 Y Y protected Y Y Y public Y Y Y Y - (2) - A: public - B:Ա private - C:췽 public - D:Ա public + (2)常见的修饰 + A:类 public + B:成员变量 private + C:构造方法 public + D:成员方法 public -5ڲ() - (1)ABڲAͱΪڲ - (2)ص㣺 - A:ڲֱӷⲿijԱ˽ - B:ⲿҪڲijԱ봴 - (3)ڲķࣺ - A:Աڲ - B:ֲڲ - (4)Աڲ +5：内部类(理解) //不常用 但是是重点，需要会使用 + (1)把类A定义在类B内部，类A就被称为内部类 + (2)访问特点： + A:内部类可以直接访问外部类的成员，包括私有 + B:外部类要想访问内部类的成员，必须创建对象 + (3)内部类的分类： + A:成员内部类 + B:局部内部类 + (4)成员内部类 A:private B:static - ⣺ + 面试题： num this.num Outer.this.num - (5)ֲڲ - A: - ֲڲʾֲfinal - (6)ڲ() - A:ûֵڲ - B:ǰ - һ߽ӿ - C:ʽ - new ߽ӿ() { - д(); + (5)局部内部类 + A:面试题 + 局部内部类访问局部变量，必须加final修饰 + (6)匿名内部类(掌握) + A:没有名字的内部类 + B:前提 + 存在一个类或者接口 + C:格式 + new 类名或者接口名() { + 重写方法(); }; - ʣһ - (7)ʹ - ڶһµˡֱͨڲĸʽͿԸ㶨 + 本质：是一个匿名子类对象 + (7)开发中如何使用 + 不用在定义一个新的类了。直接通过匿名内部类的格式就可以搞定 interface Person { public abstract void show(); @@ -94,15 +94,15 @@ pd.method(new Person(){ public void show(){...} }); - (8) - 룬ڿ̨HelloWorld + (8)面试题 + 补齐代码，在控制台输出HelloWorld interface Inter { public abstract void show(); } class Outer { - // + //补齐代码 public static Inter method() { return new Inter(){ public void show() { @@ -116,4 +116,4 @@ public static void main(String[] args) { Outer.method().show(); } - } \ No newline at end of file + }