继承性
class Subclass extends SuperClass{ }
为什么要有继承？
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可
-
此处的多个类称为子类(派生类)， 单独的这个类称为父类(基类或超类)。 可以理解为:“子类is a 父类”
-
作用：
- 继承的出现减少了代码冗余，提高了代码的复用性。
- 继承的出现，更有利于功能的扩展。
- 继承的出现让类与类之间产生了关系，提供了多态的前提。
注意：不要仅为了获取其他类中某个功能而去继承；子类不能直接访问父类中私有的(private)的成员变量和方法。
-
Java只支持单继承和多层继承，不允许多重继承。
-
一个子类只有一个父类
-
一个父类可以派生出多个子类
-
如果没有显式地声明一个类的父类的话，则此类继承于java.lang.Object类
-
所有的java类（除java.lang.Object类）都继承于java.lang.Object类
方法的重写(override/overwrite)
@Override //伪代码，可以当注释用。在子类中注释，编译器可以帮助验证是否是父类中拥有的
-
定义：在子类中可以根据需要对从父类中继承来的方法进行改造， 也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
-
要求：
- 子类重写的方法必须和父类被重写的方法具有相同的方法名称、 参数列表
- 子类重写的方法的返回值类型 不能大于父类被重写的方法的返回值类型
- 子类重写的方法使用的访问权限不能小于 父类被重写的方法的访问权限
- 子类不能重写父类中声明为private权限的方法
- 子类方法抛出的异常不能大于父类被重写方法的异常
- 子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写） 。因为static方法是属于类的，子类无法覆盖父类的方法。
- 四种访问权限修饰符：
不同包下的普通类(非子类）要使用Order类，不可以调用声明为private、缺省、protected权限的属性、方法
关键字super
- 子类继承方法重写后，如果想指定使用父类的原方法，在Java类中使用super来调用父类中的指定操作：
- super可用于访问父类中定义的属性
- super可用于调用父类中定义的成员方法
- super可用于在子类构造器中调用父类的构造器
注意：
- 尤其当子父类出现同名成员时， 可以用super表明调用的是父类中的成员
- super的追溯不仅限于直接父类
- super和this的用法相像， this代表本类对象的引用， super代表父类的内存
空间的标识
- 调用父类的构造器
- 子类中所有的构造器默认都会访问父类中空参数的构造器
- 当父类中没有空参数的构造器时， 子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。 同时， 只能”二选一”， 且必须放在构造器的首行
- 如果子类构造器中既未显式调用父类或本类的构造器， 且父类中又没有无参的构造器， 则编译出错
public class Person{
private String name;
private int age;
private Date birthDate;
public Person(String name, int age, Date d){
this.name = name;
this.age = age;
this.birthDate = d;
}
public Person(String name,int age){
this(name,age,null);
}
public Person(String name,Date d)
{
this(name,30,d)
}
public Person(String name){
this(name, 30);
}
}
public class Student extends Person{
private String school;
public Student(String name, int age, String s){
super(name, age);
school = s;
}
public Student(String name, String s){
super(name);
school = s;
}
// no super()。系统将调用父类无参数的构造器,而父类中没有这样的构造器，编译出错！！
public Student(String s){
school = s;
}
}
多态性
理解为一个事物的各种形态
对象的多态性：父类的引用指向子类的对象。可以直接应用在抽象类和接口上。
Person p = new Man(); //父类的Person指向了子类Man
Java引用变量有两个类型： 编译时类型和运行时类型。 编译时类型由声明该变量时使用的类型决定， 运行时类型由实际赋给该变量的对象决定。 简称： 编译看左；运行时看右
多态情况下， “看左边” ： 看的是引用变量父类中是否有所调用的方法（父）类中不具备子类特有（添加）的方法、属性）
“看右边” ： 看的是new的子类对象类中的重写方法（实际运行的是子类重写父类的方法）
使用场景：1.类的继承关系 2. 方法的重写
虚拟方法调用（多态情况下）
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的
-
编译时类型和运行时类型
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定
多态只适用于方法，不适用属性。
-
重写，重载与多态分析：
- 重写，子类继承父类后，可以对父类中同名同参数的方法，进行覆盖操作。表现为多态性
- 重载，是指允许存在多个同名方法，而这些方法的参数不同。 编译器根据方法不同的参数表， 对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译器就绑定了。对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，称为“早绑定”或“静态绑定”。重载不表现为多态性
- 多态，只有在方法调用的那一刻，解释运行器才会确定所要调用的具体方法，称为“晚绑定”或“动态绑定“。
易错题
public class InterviewTest{
public static void main(String[] args){
Base1 base = new Sub1();
base.add(1,2,3);
}
}
class Base1{
public void add(int a,int ... arr){
System.out.println("base1");
}
}
class Sub1 extends Base1{
//打印sub_1，多态调用子类方法
public void add(int 1,int ...arr){
System.out.println("sub_1");
}
//这段方法时子类独有的方法，打印base_1,
public void add(int a,int b,intc){
System.out.println("sub_2");
}
}
instanceof 操作符：
x instanceof A：检验x是否为类A的对象，返回值为boolean型
对象类型转换（Casting）：
- 基本数据类型的Casting：
自动类型转换：小的数据类型可以自动转换成大的数据类型，如long g=20; double d=12.0f
强制类型转换： 可以把大的数据类型强制转换(casting)成小的数据类型，如 float f=(float)12.0; int a=(int)1200L
-
对Java对象的强制类型转换称为造型
-
- 从子类到父类的类型转换可以自动进行
- 从父类到子类的类型转换必须通过造型(强制类型转换)实现
- 无继承关系的引用类型间的转换是非法的
- 在造型前可以使用instanceof操作符测试一个对象的类型
- 子类继承父类
若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量
Object类的使用
- Object类是所用Java类的根父类，如果在类的声明中未使用extends关键字指明其父类， 则默认父类为java.lang.Object类
public class Person {
...
}
等价于：
public class Person extends Object {
...
}
- ==操作符和equals方法
-
：用“==”进行比较时， 符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)， 否则编译出错
- 基本类型比较值:只要两个变量的值相等， 即为true。
- 引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时， ==才返回true。
-
equals(): 所有类都继承了Object， 也就获得了equals()方法。 还可以重写。
- 只能比较引用类型， 其作用与“==”相同,比较是否指向同一个对象。格式:obj1.equals(obj2)
- 当用equals()方法进行比较时， 对类File、 String、 Date及包装类（Wrapper Class） 来说， 是比较类型及内容而不考虑引用的是否是同一个对象；
-
重写equals()原则:
- 对称性： 如果x.equals(y)返回是“ true” ， 那么y. equals(x)也应该返回是“true” 。
- 自反性： x.equals(x)必须返回是“true”
- 传递性： 如果x.equals(y)返回是“true” ， 而且y. equals(z)返回是“true” ，那么z. equals(x)也应该返回是“true” 。
- 一致性： 如果x.equals(y)返回是“true” ， 只要x和y内容一直不变， 不管你重复x.equals(y)多少次， 返回都是“true” 。
- 任何情况下， x.equals(null)， 永远返回是“false” ；x.equals(和x不同类型的对象)永远返回是“false”
-
==和equals区别
- == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
- equals的话，它是属于java. lang. Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
- 具体要看自定义类里有没有重写Object的equals方法来判断
- 通常情况下，重写equals方法，会比较类中的相应属性是否都相等
int it = 65;
float fl = 65.0;
System.out.println(“65和65.0f是否相等？ ” + (it == fl)); //true
char ch1 = 'A'; char ch2 = 12;
System.out.println("65和'A'是否相等？ " + (it == ch1));//true
System.out.println(“12和ch2是否相等？ " + (12 == ch2));//true
//小心常量池！
String str1 = new String("hello");String str2 = new String("hello");
System.out.println("str1和str2是否相等？ "+ (str1 == str2));//false
System.out.println("str1是否equals str2？ "+(str1.equals(str2)));//true
System.out.println(“hello” == new java.util.Date()); //编译不通过
//重写equals(),以string举例
public boolean equals(Object anObject){
if(this == anObject){
return true;// 地址相同，直接返回true
}
if（anObject instanceof String){
String anotherString = (String)anObject; //类型相同，先强转
int n = value.length;
if(n == anotherString.value.length){
char v1[] = value;
char v2[] = anotherString.value; //取出值，在后面逐一比较
int i = 0;
while(n-- != 0){
if(v1[i] != v2[i]){
return false;
i++;
}
}
return true; //类都不一样，直接return false
}
}
return false;
}
toString() 方法
toString()方法在Object类中定义， 其返回值是String类型， 返回类名和它的引用地址。
public String toString(){
return getClass().getName() + "@" + Inter.toHexString(hashCode());
}
Java中的单元测试
步骤：
-
选中当前工程，右键选择 build path - add libraries - JUnit 4 - 下一步
-
创建Java类，进行测试：
- 此类是公共的
- 此类提供公共的无参构造器
- 此类中声明单元测试方法，方法权限是public，没有返回值，没有形参
public void testEquals()
- 此单元测试方法上须声明注释：@Test，并在单元测试类中导入： import org.junit.Test;
4. 声明好单元测试方法后，可以在方法体内测试相关代码。
5. 写完代码后，左键双击单元测试方法，右键：run as - JUnit Test
说明：
-
执行结果没有异常：绿条
- 执行结果出现异常：红条
包装类的使用
基本数据类型—》包装类—》多态
- 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
- 有了类的特点，就可以调用类中的方法， Java才是真正的面向对象
toString() 方法
toString()方法在Object类中定义， 其返回值是String类型， 返回类名和它的引用地址。
public String toString(){
return getClass().getName() + "@" + Inter.toHexString(hashCode());
}
Java中的单元测试
步骤：
-
选中当前工程，右键选择 build path - add libraries - JUnit 4 - 下一步
-
创建Java类，进行测试：
- 此类是公共的
- 此类提供公共的无参构造器
- 此类中声明单元测试方法，方法权限是public，没有返回值，没有形参
public void testEquals()
- 此单元测试方法上须声明注释：@Test，并在单元测试类中导入： import org.junit.Test;
4. 声明好单元测试方法后，可以在方法体内测试相关代码。
5. 写完代码后，左键双击单元测试方法，右键：run as - JUnit Test
说明：
-
执行结果没有异常：绿条
- 执行结果出现异常：红条
包装类的使用
基本数据类型—》包装类—》多态
- 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
- 有了类的特点，就可以调用类中的方法， Java才是真正的面向对象
基本类型、包装类与String类间的转换
JDK 5,0 新特性：自动装箱与自动拆箱：基本数据类型 《---》包装类
//自动装箱：
int num2 = 10;
Integer in1 = num2;
boolean b1 = true;
Boolean b2 = b1; //直接装箱了
//自动拆箱
int num3 = in1;
// String类型 ---》 基本数据类型、包装类、调用包装类 parseXxx(String s)
int num2 = Integer.parseInt(str1);
注意IntegerCache结构中的定义，是保存-128~127的整数，如果使用自动装箱声称对象则指向同一地址。如果是128，就会new一个新地址
2900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
