尚硅⾕Java——宋红康笔记【day11-day18】
day11
Eclipse中的快捷键：
* 1.补全代码的声明：alt + /
* 2.快速修复: ctrl + 1
* 3.批量导包：ctrl + shift + o
* 4.使⽤单⾏注释：ctrl + /
* 5.使⽤多⾏注释： ctrl + shift + /
* 6.取消多⾏注释：ctrl + shift + \
* 7.复制指定⾏的代码：ctrl + alt + down 或 ctrl + alt + up
* 8.删除指定⾏的代码：ctrl + d
* 9.上下移动代码：alt + up  或 alt + down
* 10.切换到下⼀⾏代码空位：shift + enter
* 11.切换到上⼀⾏代码空位：ctrl + shift + enter
* 12.如何查看源码：ctrl + 选中指定的结构或  ctrl + shift + t
* 13.退回到前⼀个编辑的页⾯：alt + left
* 14.进⼊到下⼀个编辑的页⾯(针对于上⾯那条来说的)：alt + right
* 15.光标选中指定的类，查看继承树结构：ctrl + t
* 16.复制代码： ctrl + c
* 17.撤销： ctrl + z
* 18.反撤销： ctrl + y
* 19.剪切：ctrl + x
* 20.粘贴：ctrl + v
* 21.保存： ctrl + s
* 22.全选：ctrl + a
* 23.格式化代码： ctrl + shift + f
* 24.选中数⾏，整体往后移动：tab
* 25.选中数⾏，整体往前移动：shift + tab
* 26.在当前类中，显⽰类结构，并⽀持搜索指定的⽅法、属性等：ctrl + o
* 27.批量修改指定的变量名、⽅法名、类名等：alt + shift + r
* 28.选中的结构的⼤⼩写的切换：变成⼤写： ctrl + shift + x
* 29.选中的结构的⼤⼩写的切换：变成⼩写：ctrl + shift + y
* 30.调出⽣成getter/setter/构造器等结构： alt + shift + s
* 31.显⽰当前选择资源(⼯程 or ⽂件)的属性：alt + enter
* 32.快速查：参照选中的Word快速定位到下⼀个：ctrl + k
* 33.关闭当前窗⼝：ctrl + w
* 34.关闭所有的窗⼝：ctrl + shift + w
* 35.查看指定的结构使⽤过的地⽅：ctrl + alt + g
* 36.查与替换：ctrl + f
* 37.最⼤化当前的View：ctrl + m
* 38.直接定位到当前⾏的⾸位：home
* 39.直接定位到当前⾏的末位：end
⾯向对象的特征之⼆：继承性 why?
⼀、继承性的好处：
① 减少了代码的冗余，提⾼了代码的复⽤性
② 便于功能的扩展
③ 为之后多态性的使⽤，提供了前提
⼆、继承性的格式： class A extends B{}
A:⼦类、派⽣类、subclass
B:⽗类、超类、基类、superclass
2.1体现：⼀旦⼦类A继承⽗类B以后，⼦类A中就获取了⽗类B中声明的所有的属性和⽅法。特别的，⽗类中声明为private的属性或⽅法，⼦类继承⽗类以后，仍然认为获取了⽗类中私有的结构。只有因为封装性的影响，使得⼦类不能直接调⽤⽗类的结构⽽已。
2.2 ⼦类继承⽗类以后，还可以声明⾃⼰特有的属性或⽅法：实现功能的拓展。⼦类和⽗类的关系，不同于⼦集和集合的关系。
extends：延展、扩展
三、Java中关于继承性的规定：
1.⼀个类可以被多个⼦类继承。
2.Java中类的单继承性：⼀个类只能有⼀个⽗类
3.⼦⽗类是相对的概念。
4.⼦类直接继承的⽗类，称为：直接⽗类。间接继承的⽗类称为：间接⽗类
5.⼦类继承⽗类以后，就获取了直接⽗类以及所有间接⽗类中声明的属性和⽅法
四、 1.如果我们没有显式的声明⼀个类的⽗类的话，则此类继承于java.lang.Object类
2.所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
3.意味着，所有的java类具有java.lang.Object类声明的功能。
day12
⽅法的重写(override / overwrite)
1.重写：⼦类继承⽗类以后，可以对⽗类中同名同参数的⽅法，进⾏覆盖操作
2.应⽤：重写以后，当创建⼦类对象以后，通过⼦类对象调⽤⼦⽗类中的同名同参数的⽅法时，实际执⾏的是⼦类重写⽗类的⽅法。
重写的规定：
⽅法的声明：权限修饰符返回值类型⽅法名(形参列表) throws 异常的类型{}
约定俗称：⼦类中的叫重写的⽅法，⽗类中的叫被重写的⽅法
① ⼦类重写的⽅法的⽅法名和形参列表与⽗类被重写的⽅法的⽅法名和形参列表相同
② ⼦类重写的⽅法的权限修饰符不⼩于⽗类被重写的⽅法的权限修饰符
特殊情况：⼦类不能重写⽗类中声明为private权限的⽅法
③ 返回值类型：
⽗类被重写的⽅法的返回值类型是void，则⼦类重写的⽅法的返回值类型只能是void
⽗类被重写的⽅法的返回值类型是A类型，则⼦类重写的⽅法的返回值类型可以是A类或A类的⼦类
⽗类被重写的⽅法的返回值类型是基本数据类型(⽐如：double)，则⼦类重写的⽅法的返回值类型必须是相同的基本数据类型(必须也是double)
④ ⼦类重写的⽅法抛出的异常类型不⼤于⽗类被重写的⽅法抛出的异常类型（具体放到异常处理时候讲）
⼦类和⽗类中的同名同参数的⽅法要么都声明为⾮static的（考虑重写），要么都声明为static的（不是重写）。
⾯试题：区分⽅法的重载与重写
super关键字的使⽤
1.super理解为：⽗类的
2.super可以⽤来调⽤：属性、⽅法、构造器
3.super的使⽤：调⽤属性和⽅法
3.1 我们可以在⼦类的⽅法或构造器中。通过使⽤"super.属性"或"super.⽅法"的⽅式，显式的调⽤⽗类中声明的属性或⽅法。但是，通常情况下，我们习惯省略"super."
3.2 特殊情况：当⼦类和⽗类中定义了同名的属性时，我们要想在⼦类中调⽤⽗类中声明的属性，则必须显式的使⽤"super.属性"的⽅式，表明调⽤的是⽗类中声明的属性。
3.3 特殊情况：当⼦类重写了⽗类中的⽅法以后，我们想在⼦类的⽅法中调⽤⽗类中被重写的⽅法时，则必须显式的使⽤"super.⽅法"的⽅式，表明调⽤的是⽗类中被重写的⽅法。
4.super调⽤构造器
4.1 我们可以在⼦类的构造器中显式的使⽤"super(形参列表)"的⽅式，调⽤⽗类中声明的指定的构造器
4.2 "super(形参列表)"的使⽤，必须声明在⼦类构造器的⾸⾏！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能⼆选⼀，不能同时出现
4.4 在构造器的⾸⾏，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调⽤的是⽗类中空参的构造器：super()
4.5 在类的多个构造器中，⾄少有⼀个类的构造器中使⽤了"super(形参列表)"，调⽤⽗类中的构造器
⼦类对象实例化的全过程
1.从结果上来看：（继承性）
⼦类继承⽗类以后，就获取了⽗类中声明的属性或⽅法。
创建⼦类的对象，在堆空间中，就会加载所有⽗类中声明的属性。
2.从过程上来看：
当我们通过⼦类的构造器创建⼦类对象时，我们⼀定会直接或间接的调⽤其⽗类的构造器，进⽽调⽤⽗类的⽗类的构造器，...
直到调⽤了java.lang.Object类中空参的构造器为⽌。正因为加载过所有的⽗类的结构，所以才可以看到内存中有
⽗类中的结构，⼦类对象才可以考虑进⾏调⽤。
明确：虽然创建⼦类对象时，调⽤了⽗类的构造器，但是⾃始⾄终就创建过⼀个对象，即为new的⼦类对象
⾯向对象特征之三：多态性
1.理解多态性：可以理解为⼀个事物的多种形态。
2.何为多态性：
对象的多态性：⽗类的引⽤指向⼦类的对象（或⼦类的对象赋给⽗类的引⽤）
多态的使⽤：虚拟⽅法调⽤
有了对象的多态性以后，我们在编译期，只能调⽤⽗类中声明的⽅法，但在运⾏期，我们实际执⾏的是⼦类重写⽗类的⽅法。
总结：编译，看左边；运⾏，看右边。
4.多态性的使⽤前提： ① 类的继承关系 ② ⽅法的重写
5.对象的多态性，只适⽤于⽅法，不适⽤于属性（编译和运⾏都看左边）
day13
instanceof的使⽤和向下转型
x instanceof A：检验x是否为类A的对象，返回值为boolean型
使⽤情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进⾏instanceof的判断，⼀旦返回true，就进⾏向下转型。如果返回false，不进⾏向下转型。
如果 a instanceof A返回true，则 a instanceof B也返回true.其中，类B是类A的⽗类。
多态的使⽤：当调⽤⼦⽗类同名同参数的⽅法时，实际执⾏的是⼦类重写⽗类的⽅法 ---虚拟⽅法调⽤
有了对象的多态性以后，内存中实际上是加载了⼦类特有的属性和⽅法的，但是由于变量声明为⽗类类型，导致编译时，只能调⽤⽗类中声明的属性和⽅法。⼦类特有的属性和⽅法不能调⽤。
如何才能调⽤⼦类特有的属性和⽅法？—— 向下转型：使⽤强制类型转换符。（Man m1 = (Man)p2;）
java.lang.Object类
1.Object类是所有Java类的根⽗类
2.如果在类的声明中未使⽤extends关键字指明其⽗类，则默认⽗类为java.lang.Object类
3.Object类中的功能(属性、⽅法)就具有通⽤性。
属性：⽆
⽅法：equals() / toString() / getClass() /hashCode() / clone() / finalize() / wait() 、 notify()、notifyAll()
4.Object类只声明了⼀个空参的构造器
equals()
⼀、回顾 == 的使⽤：
== ：运算符
1.可以使⽤在基本数据类型变量和引⽤数据类型变量中
2.如果⽐较的是基本数据类型变量：⽐较两个变量保存的数据是否相等。（不⼀定类型要相同）
java valueof如果⽐较的是引⽤数据类型变量：⽐较两个对象的地址值是否相同.即两个引⽤是否指向同⼀个对象实体
补充： == 符号使⽤时，必须保证符号左右两边的变量类型⼀致。
⼆、equals()⽅法的使⽤：
1.是⼀个⽅法，⽽⾮运算符
2.只能适⽤于引⽤数据类型
3.Object类中equals()的定义：
public boolean equals(Object obj) {
return (this == obj);
}
说明：Object类中定义的equals()和==的作⽤是相同的：⽐较两个对象的地址值是否相同.即两个引⽤是否指向同⼀个对象实体
4.像String、Date、File、包装类等都重写了Object类中的equals()⽅法。重写以后，⽐较的不是两个引⽤的地址是否相同，⽽是⽐较两个对象的"实体内容"是否相同。
5.通常情况下，我们⾃定义的类如果使⽤equals()的话，也通常是⽐较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进⾏重写.
重写的原则：⽐较两个对象的实体内容是否相同
bject类中toString()的使⽤：
1.当我们输出⼀个对象的引⽤时，实际上就是调⽤当前对象的toString()
2.Object类中toString()的定义：
public String toString() {
return getClass().getName() + "@" + HexString(hashCode());
}
3.像String、Date、File、包装类等都重写了Object类中的toString()⽅法。使得在调⽤对象的toString()时，返回"实体内容"信息
4.⾃定义类也可以重写toString()⽅法，当调⽤此⽅法时，返回对象的"实体内容"
Java中的JUnit单元测试
（eclipse）步骤：
1.选中当前⼯程 - 右键选择：build path - add libraries - JUnit 4 - 下⼀步
2.创建Java类，进⾏单元测试。此时的Java类要求：① 此类是public的 ②此类提供公共的⽆参的构造器
3.此类中声明单元测试⽅法。此时的单元测试⽅法：⽅法的权限是public，没有返回值，没有形参
4.此单元测试⽅法上需要声明注解：@Test，并在单元测试类中导⼊：import org.junit.Test;
5.声明好单元测试⽅法以后，就可以在⽅法体内测试相关的代码。
6.写完代码以后，左键双击单元测试⽅法名，右键：run as - JUnit Test
说明：
1.如果执⾏结果没有任何异常：绿条
2.如果执⾏结果出现异常：红条
包装类
1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
2.掌握的：基本数据类型、包装类、String三者之间的相互转换
基本数据类型 --->包装类：调⽤包装类的构造器
public void test1(){
int num1 = 10;
//      System.out.String());
Integer in1 = new Integer(num1);
System.out.String());
Integer in2 = new Integer("123");
System.out.String());
//报异常
//      Integer in3 = new Integer("123abc");
//      System.out.String());
Float f1 = new Float(12.3f);
Float f2 = new Float("12.3");
System.out.println(f1);
System.out.println(f2);
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("TrUe");
System.out.println(b2);
Boolean b3 = new Boolean("true123");
System.out.println(b3);//false
//特别注意此处，分别是boolean和Boolean，都没定义的情况下⼀个返回false⼀个返回null
Order order = new Order();
System.out.println(order.isMale);//false
System.out.println(order.isFemale);//null
}
}
class Order{
boolean isMale;
Boolean isFemale;
}
基本数据类型：调⽤包装类Xxx的xxxValue()
public void test2(){
Integer in1 = new Integer(12);
int i1 = in1.intValue();
System.out.println(i1 + 1);
Float f1 = new Float(12.3);
float f2 = f1.floatValue();
System.out.println(f2 + 1);
}
JDK 5.0 新特性：⾃动装箱 与⾃动拆箱
public void test3(){
//int num1 = 10;
//基本数据类型-->包装类的对象
//method(num1);
//⾃动装箱：基本数据类型 --->；包装类
int num2 = 10;
Integer in1 = num2;//⾃动装箱
boolean b1 = true;
Boolean b2 = b1;//⾃动装箱
//⾃动拆箱：包装类--->；基本数据类型
System.out.String());
int num3 = in1;//⾃动拆箱
}
public void method(Object obj){
System.out.println(obj);
}
基本数据类型、包装类--->String类型：调⽤String重载的valueOf(Xxx xxx) public void test4(){
int num1 = 10;
//⽅式1：连接运算
String str1 = num1 + "";
//⽅式2：调⽤String的valueOf(Xxx xxx)
float f1 = 12.3f;
String str2 = String.valueOf(f1);//"12.3"
Double d1 = new Double(12.4);
String str3 = String.valueOf(d1);
System.out.println(str2);
System.out.println(str3);//"12.4"
}
String类型 --->基本数据类型、包装类：调⽤包装类的parseXxx(String s) public void test5(){
String str1 = "123";
//错误的情况：没有相关性
//int num1 = (int)str1;
//Integer in1 = (Integer)str1;
/
/可能会报NumberFormatException
int num2 = Integer.parseInt(str1);
System.out.println(num2 + 1);
String str2 = "true1";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
}
总结
包装类⾯试题
题1

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。