面向对象《二》

1、继承

1）多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中， 那么多个类无需再定义这些属性和行为，只要继承那个类即可。

2）此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”

3）类继承语法规则: class Subclass extends SuperClass{ }

作用：继承的出现减少了代码冗余，提高了代码的复用性。继承的出现，更有利于功能的扩展。继承的出现让类与类之间产生了关系，提供了多态的前提。

2、继承的规则

1）子类不能直接访问父类中私有的(private)的成员变量和方法。

2）权限修饰符

3）Java只支持单继承和多层继承，不允许多重继承（一个子类只能有一个父类，一个父类可以派生出多个子类）

3、方法重写（Override）

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称 为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

1）子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

2）子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

3）子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限，子类不能重写父类中声明为private权限的方法

4）子类方法抛出的异常不能大于父类被重写方法的异常

注意：子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为 static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。重写是无法重写类属性的。

4、关键字super

定义：在Java类中使用super来调用父类中的指定操作

1）super可用于访问父类中定义的属性

2）super可用于调用父类中定义的成员方法

3）super可用于在子类构造器中调用父类的构造器

注意：

1）尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员

2）super的追溯不仅限于直接父类

3）super和this的用法相像，this代表本类对象的引用，super代表父类的内存 空间的标识

调用父类构造器

1）子类中所有的构造器默认都会访问父类中空参数的构造器（如果子类构造器第一行使用了this或者super调用其他构造器就不会默认访问父类中空参数的构造器）

2）当父类中没有空参数的构造器时，子类的构造器必须通过this(参 数列表)或者super(参数列表)语句指定调用本类或者父类中相应的 构造器。同时，只能”二选一” ，且必须放在构造器的首行

3）如果子类构造器中既未显式调用父类或本类的构造器，且父类中又 没有无参的构造器，则编译出错

import java.util.Date;
import java.util.Scanner;

class Person {
    private String name;
    private int age;
    private Date birthDate;
//    public Person() { //不加这个构造器会报错
//        
//    }
    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);
    }
}

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;
    }
}

public class Main {
    public static void main(String[] args) {
        
    }
}

5、this和super的区别

6、子类对象实例化过程

7、多态性

在Java中的体现： 对象的多态性：父类的引用指向子类的对象（可以直接应用在抽象类和接口上）

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明 该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简 称：编译时，看左边；运行时，看右边。

1）若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)

2）多态情况下， “看左边” ：看的是父类的引用（父类中不具备子类特有的方法） “看右边” ：看的是子类的对象（实际运行的是子类重写父类的方法）

对象的多态 —在Java中,子类的对象可以替代父类的对象使用：

1）一个变量只能有一种确定的数据类型

2）一个引用类型变量可能指向(引用)多种不同类型的对象

Person p = new Student(); Object o = new Person();//Object类型的变量o，指向Person类型的对象

o = new Student(); //Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向 上转型(upcasting)。

注意：一个引用类型变量如果声明为父类的类型，但实际引用的是子类 对象，那么该变量就不能再访问子类中添加的属性和方法

import java.util.Date;
import java.util.Scanner;

class Person1 {
    private String name;
    private int age;
    private Date birthDate;

    public Person1() {

    }
    
    public void eat() {
        System.out.println("父类");
    }
}

class Student extends Person1 {
    private String school;
    //@Override 加不加这个都行
    public void eat() {
        System.out.println("子类");
    }

    public Student() {
    }
}

public class Main {
    public static void main(String[] args) {
        Person1 p = new Student();
        p.eat();
    }
}

 

8、虚拟方法调用

从编译和运行的角度看：

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不 同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了 不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类 和子类的，即子类可以重载父类的同名不同参数的方法。 所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法， 这称为“早绑定”或“静态绑定”；

而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体 方法，这称为“晚绑定”或“动态绑定”。

9、instanceof操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

1）要求x所属的类与类A必须是子类和父类的关系，否则编译错误。

2）如果x属于类A的子类B，x instanceof A值也为true。

public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}
-------------------------------------------------------------------
public void method1(Person e) {
if (e instanceof Person) 
// 处理Person类及其子类对象
if (e instanceof Student) 
//处理Student类及其子类对象
if (e instanceof Graduate)
//处理Graduate类及其子类对象
}

10、对象类型转换

基本数据类型的Casting：

1）自动类型转换：小的数据类型可以自动转换成大的数据类型 如

long g=20; double d=12.0f

2）强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型 如

float f=(float)12.0; int a=(int)1200L

 

对Java对象的强制类型转换称为造型

1）从子类到父类的类型转换可以自动进行

2）从父类到子类的类型转换必须通过造型(强制类型转换)实现

3）无继承关系的引用类型间的转换是非法的

4）造型前可以使用instanceof操作符测试一个对象的类型

public class ConversionTest {
public static void main(String[] args) {
double d = 13.4;
long l = (long) d;
System.out.println(l);
int in = 5;
// boolean b = (boolean)in;
Object obj = "Hello";
String objStr = (String) obj;
System.out.println(objStr);
Object objPri = new Integer(5);
// 所以下面代码运行时引发ClassCastException异常
String str = (String) objPri;
}
}

注意：

1）若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的 同名方法，系统将不可能把父类里的方法转移到子类中。

2）对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的 实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

多态是运行时行为

11、Object类的使用

1）Object类是所有Java类的根父类

2）如果在类的声明中未使用extends关键字指明其父类，则默认父类 为java.lang.Object类

public class Person { ... } 等价于： public class Person extends Object { ... }

12、==操作符与equals方法

==：

1）对基本数据类型

基本类型比较值:只要两个变量的值相等，即为true。 int a=5; if(a==6){…}

2）对引用数据类型

引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才 返回true。

Person p1=new Person();

Person p2=new Person();

if (p1==p2){…}

用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本 数据类型除外)，否则编译出错

 

equals：所有类都继承了Object，也就获得了equals()方法。还可以重写。

1）只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。

格式：obj1.equals(obj2)

特例：当用equals()方法进行比较时，对类File、String、Date及包装类 （Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；

原因：在这些类中重写了Object类的equals()方法。

int it = 65;
float fl = 65.0f;
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()); //编译不通过

13、重写equals的原则

1）对称性：如果x.equals(y)返回是“true” ，那么y.equals(x)也应该返回是 “true”。

2） 自反性：x.equals(x)必须返回是“true”。

3）传递性：如果x.equals(y)返回是“true” ，而且y.equals(z)返回是“true” ， 那么z.equals(x)也应该返回是“true”。

4） 一致性：如果x.equals(y)返回是“true” ，只要x和y内容一直不变，不管你 重复x.equals(y)多少次，返回都是“true”。

5） 任何情况下，x.equals(null)，永远返回是“false” ； x.equals(和x不同类型的对象)永远返回是“false”。

14、toString方法

1）toString()方法在Object类中定义，其返回值是String类型，返回类名和它 的引用地址。

2）可以根据需要在用户自定义类型中重写toString()方法

3）基本类型数据转换为String类型时，调用了对应包装类的toString()方法 int a=10; System.out.println(“a=”+a);

char[] arr = new char[] { 'a', 'b', 'c' };
        System.out.println(arr);//abc，除了char型数组，其他的都输出地址值
        int[] arr1 = new int[] { 1, 2, 3 };
        System.out.println(arr1);//地址
        double[] arr2 = new double[] { 1.1, 2.2, 3.3 };
        System.out.println(arr2);//地址

15、包装类的使用

1）针对八种基本数据类型定义相应的引用类型—包装类（封装类）

2）有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

3）基本数据类型包装成包装类的实例 ---装箱

通过包装类的构造器实现： int i = 500; Integer t = new Integer(i);

还可以通过字符串参数构造包装类对象： Float f = new Float(“4.56”);

Long l = new Long(“asdf”); //NumberFormatException

4）获得包装类对象中包装的基本类型变量 ---拆箱

调用包装类的.xxxValue()方法： boolean b = bObj.booleanValue();

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

16、基本类型、包装类与String类间的转换

public class Main {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);//false    比较地址
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);//true　　 使用自动装箱，Integer类中有一个IntegerCache子类，这个子类维护一个数组
        Integer x = 128;　　　　//这个数据里面把-128——127内的所有数提前实例化（new）出来，因为这区间的数用的概率比较大
        Integer y = 128;　　　　//所以你在给1这个数字装箱的时候用的是早已经实例化过的一个地址
        System.out.println(x == y);//false

    }
}

public class Main {
    public static void main(String[] args) {
　　　　　//对这个三元运算符编译的时候就需要统一转换成一个类型，因为double类型比int大，所以都需要转换成double类型，所以结果也就是1.0
        Object o1 = true ? new Integer(1) : new Double(2.0);
        System.out.println(o1);//1.0
        
        Object o2;
        if (true)
        o2 = new Integer(1);
        else
        o2 = new Double(2.0);
        System.out.println(o2);//1

    }
}