03 面向对象（中）

西瓜和芒果
131 阅读14分钟

1. OOP特征二：继承性

  • 为描述和处理个人信息，定义类Person： 
class Person {
    public String name;
    public int age;
    public Date birthDate;
    
    public String getInfo() {
        // ...
    }
}
  • 为描述和处理学生信息，定义类Student： 
class Student {
    public String name;
    public int age;
    public Date birthDate;
    public String school;
    
    public String getInfo() {
        // ...
    }
}
  • 通过继承，简化Student类的定义 
class Person {
	public String name;
	public int age;
	public Date birthDate;
	
	public String getInfo() {
		// ...
	}
}

class Student extends Person {
	public String school;
}
    • Student类继承了父类Person的所有属性和方法，并增加了一个属性school。Person中的属性和方法，Student都可以使用。

  • 为什么要有继承？ 
    • 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，name多个类无需再定义这些属性和行为，只要继承那个类即可。
  • 此处的多个类称为子类（派生类），单独的这个类称为父类（基类或超类）。 
  • 类继承语法规则：
    class Subclass extends SuperClass{}
  • 作用： 
    • 继承的出现减少了代码冗余，提高了代码的复用性。
    • 继承的出现，更有利于功能的扩展。
    • 继承的出现让类与类之间产生了关系，提供了多态的前提。
  • 注意：不要仅为了获取其他类中某个功能而去继承。 

关于继承的规则：

  • 子类不能直接访问父类中私有的（private）的成员变量和方法。
  • Java只支持单继承和多层继承，不允许多重继承 
    • 一个子类只能有一个父类
    • 一个父类可以派生出多个子类 
      • class SubDemo extends Demo{} // ok
      • class SubDemo extends Demo1, Demo2...    // error

2. 方法的重写（override）

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

要求：

  1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
  2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
  3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限 
    • 子类不能重写父类中声明为private权限的方法
  1. 子类方法抛出的异常不能大于父类被重写方法的异常

注意：

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

重写方法举例1：

public class Person {
	public String name;
	public int age;
	public String getInfo() {
		return "Name: " + name + "\n" + "age: " + age;
	}
}

public class Student extends Person {
	public String school;
	public String getInfo() {	// 重写方法
		return "Name: " + name + "\n age: " + age + "\n school: " + school;
	}
	public static void main(String args[]) {
		Student s1 = new Student();
		s1.name = "Bob";
		s1.age = 20;
		s1.school = "school2";
		System.out.println(s1.getInfo());	// Name: Bob age: 20	school: school2
	}
}

Person p1 = new Person();
// 调用Person类的getInfo()方法
p1.getInfo();
Student s1 = new Student();
// 调用Student类的getInfo()方法
s1.getInfo();
// 这是一种“多态性”：同名的方法，用不同的对象来区分调用的是哪一个方法。

重写方法举例2

class Parent {
    public void method1() {}
}

class Child extends Parent {
    // 非法，子类中的method1()的访问权限private比被覆盖方法的访问权限public小
    private void method1() {}
}

public class UseBoth {
    public static void main(String[] args) {
        Parent p1 = new Parent();
        Child c1 = new Child();
        p1.method1();
        c1.method1();
    }
}

3. 四种访问权限修饰符

Java权限修饰符public、protected、（缺省）、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

修饰符类内部同一个包不同包的子类同一个工程
privateY
(缺省)YY
protectedYYY
publicYYYY

对于class的权限修饰只可以用public和default（缺省）。

  • public类可以在任意地方被访问。
  • default类只可以被同一个包内部的类访问。

访问控制举例

class Parent {
	private int f1 = 1;
	int f2 = 2;
	protected int f3 = 3;
	public int f4 = 4;
	
	private void fm1() {
		System.out.println("in fm1()f1=" + f1);
	}
	void fm2() {
		System.out.println("in fm2()f2=" + f2);
	}
	protected void fm3() {
		System.out.println("in fm3()f3=" + f3);
	}
	public void fm4() {
		System.out.println("in fm4()f4=" + f4;)
	}
}

访问控制举例

class Child extends Parent {	// 设父类和子类在同一个包内
    private int c1 = 21;
    public int c2 = 22;
    
    private void cm1() {
        System.out.println("in cm1() c1=" + c1);
    }
    public void cm2() {
        System.out.println("in cm2() c2=" + c2);
    }
    
    public static void main(String[] args) {
        int i;
        Parent p = new Parent();
        i = p.f2;	// i = p.f3;	i = p.f4;
        p.fm2();	// p.fm3();		p.fm4();
        Child c = new Child();
        i = c.f2;	// i = c.f3;	i = c.f4;
        i = c.c1;	// i = c.c2;
        c.cm1();	// c.cm2();	c.fm2(); c.fm3(); c.fm4()
    }
}

4. 关键字：super

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

  • super可用于访问父类中定义的属性
  • super可用于调用父类中定义的成员方法
  • super可用于在子类构造器中调用父类的构造器

注意：

  • 尤其当子类出现同名成员时，可以用super表明调用的是父类中的成员
  • super的追溯不仅限于直接父类
  • super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识
class Person {
    protected String name = "张三";
    protected int age;
    public String getInfo() {
        return "Name: " + name + "\n age: " + age;
    }
}
class Student extends Person {
    protected String name = "李四";
    private String school = "New Oriental";
    public String getSchool() {
        return school;
    }
    public String getInfo() {
        return super.getInfo() + "\n school: " + school;
    }
}
public class StudentTest {
    public static void main(String[] args) {
        Student st = new Student();
        System.out.println(st.getInfo());
    }
}

调用父类的构造器

  • 子类中所有的构造器默认都会访问父类中空参数的构造器
  • 当父类中没有空参数的构造器时，子类的构造器必须通过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;
	}
}

this和super的区别

区别点thissuper
访问属性访问本类中的属性，如果本类没有此属性则从父类中继续查找直接访问父类中的属性
调用方法访问本类中的方法，如果本类没有此方法则从父类中继续查找直接访问父类中的方法
调用构造器调用本类构造器，必须放在构造器的首行调用父类构造器，必须放在子类构造器的首行

5. 子类对象实例化过程

class Creature {
    public Creature() {
        System.out.println("Creature无参数的构造器");
    }
}
class Animal extends Creature {
    public Animal(String name) {
        System.out.println("Animal带一个参数的构造器，该动物的name为 " + name);
    }
    public Animal(String name, int age) {
        this(name);
        System.out.println("Animal带两个参数的构造器，其age为" + age);
    }
}
public class Wolf extends Animal {
    public Wolf() {
        super("灰太狼", 3);
        System.out.println("Wolf无参数的构造器");
    }
    public static void main(String[] args) {
        new Wolf();
    }
}

6. OOP特征三：多态性

多态性，是面向对象中最重要的概念，在Java中的体现：

  • 对象的多态性：父类的引用指向子类的对象
  • 可以直接应用在抽象类和接口上

Java引用变量有两个类型：

  • 编译时类型
  • 运行时类型

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

  • 若编译时类型和运行时类型不一致，就出现了对象的多态性（Polymorphism）
  • 多态情况下， 
    • 看左边：看的是父类的引用（父类中不具备子类特有的方法）
    • 看右边：看的是子类的对象（实际运行的是子类重写父类的方法）

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

  • 一个变量只能有一种确定的数据类型
  • 一个引用类型变量可能指向（引用）多种不同类型的对象
Person p = new Student();
Object o = new Person();	// Object 类型的变量 o，指向 Person 类型的对象
o = new Student();		// Object 类型的变量o，指向 Student 类型的对象

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

  • 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。 
Student m = new Student();
m.school = "pku";	// 合法，Student类有school成员变量
Person e = new Student();
e.school = "pku";	// 非法，Person类没有school成员变量

属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

多态性应用举例

  • 方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法 
public class Test {
    public void method(Person e) {
        // ....
        e.getInfo();
    }
    public static void main(String args[]) {
        Test t = new Test();
        Student m = new Student();
        t.method(m);	// 子类的对象m传送给父类类型的参数e
    }
}

虚拟方法调用（Virtual Method Invocation）

  • 正常的方法调用 
Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();
  • 虚拟方法调用（多态情况下）
    子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。 
Person e = new Student();
e.getInfo();	// 调用Student类的getInfo()方法
  • 编译时类型和运行时类型
    编译时e为Person类型，而方法的调用时在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定 

虚拟方法调用举例

前提：Person类中定义了welcome()方法，各个子类重写了welcome()。

执行：多态的情况下，调用对象的welcome()方法，实际执行的是子类重写的方法。

总结

多态作用：

  • 提高了代码的通用性，常称作接口重用

前提：

  • 需要存在继承或者实现关系
  • 有方法的重写

成员方法：

  • 编译时：要查看引用变量所声明的类中是否有所调用的方法。
  • 运行时：调用实际new的对象所属的类中的重写方法。

成员变量：

  • 不具备多态性，只看引用变量所声明的类。

instanceof 操作符

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

  • 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
  • 如果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类及其子类对象
}

对象类型转换（Casting）

基本数据类型的Casting：

  • 自动类型转换：小的数据类型可以自动转换成大的数据类型
    如 long g = 20; double d = 12.0f 
  • 强制类型转换：可以把大的数据类型强制转换（casting）成小的数据类型
    如 float f = (float)12.0; int a = (int)1200L 

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

  • 从子类到父类的类型转换可以自动进行
  • 从父类到子类的类型转换必须通过造型（强制类型转换）实现
  • 无法继承关系的引用类型键的转换是非法的
  • 在造型前可以使用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;
    }
}

public class Test {
	public void method(Person e) {	// 设置Person类中没有getschool()方法
		// System.out.println(e.getschool());	// 非法，编译时错误
		if(e instanceof Student) {
			Student me = (Student) e;	// 将e强制转换为Student类型
			System.out.println(me.getschool());
		}
	}
	public static void main(String[] args) {
		Test t = new Test();
		Student m = new Student();
		t.method(m);
	}
}

继承成员变量和继承方法的区别

class Base {
    int count = 10;
    public void display() {
        System.out.println(this.count);
    }
}

class Sub extends Base {
    int count = 20;
    public void display() {
        System.out.println(this.count);
    }
}

public class FieldMethodTest {
    public static void main(String[] args) {
        Sub s = new Sub();
        System.out.println(s.count);
        s.display();
        Base b = s;
        System.out.println(b == s);
        System.out.println(b.count);
        b.display();
    }
}

子类继承父类

  • 若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
  • 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量。

7. Object类的使用

Object类是所有Java类的根父类

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

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

如：

method(Object obj){...}	// 可以接收任何类作为其参数
Person o = new Person();
method(o);
方法名称类型描述
public Object()构造构造器
public boolean equals(Object obj)普通对象比较
public int hashCode()普通取得Hash码
public String toString()普通对象打印时调用

==操作符与equals方法

==
  • 基本类型比较值：只要两个变量的值相等，即为true。
    int a = 5; if(a==6){...}
  • 引用类型比较引用（是否指向同一个对象）：只有指向同一个对象时，==才返回true。 
Person p1 = new Person();
Person p2 = new Person();
if(p1 == p2) {...}
    • 用==进行比较时，符号两边的数据类型必须兼容（可自动转换的基本数据类型除外），否则编译出错。
equals()

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

  • 只能比较引用类型，其作用与==相同，比较是否指向同一个对象。
  • 格式：obj1.equals(obj2)
特例

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

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

当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等。

重写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”。

8. 包装类的使用

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

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

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean
charCharacter

从Byte~Double的父类为：Number

  • 基本数据类型包装成包装类的实例  ——装箱 
    • 通过包装类的构造器实现： 
int i = 500; Integer t = new Integer(i);
    • 还可以通过字符串参数构造包装类对象： 
Float f = new Float("4.56");
Long I = new Long("asdf");	// NumberFormatException
  • 获得包装类对象中包装的基本类型变量 ——拆箱 
    • 调用包装类的.xxxValue()方法：
      boolean b = bObj.booleanValue();
  • JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。 
  • 字符串转换成基本数据类型 
    • 通过包装类的构造器实现：
      int i = new Integer("12");
    • 通过包装类的parseXxx(String s)静态方法：
      Float f = Float.parseFloat("12.1");
  • 基本数据类型转换成字符串 
    • 调用字符串重载的valueOf()方法：
      String fstr = String.valueOf(2.34f);
    • 更直接的方式：
      String intStr = 5 + ""

总结：基本类型、包装类与String类间的转换

包装类用法举例

int i = 500;
Integer t = new Integer(i);

装箱：包装类使得一个基本数据类型的数据变成了类。

有了类的特点，可以调用类中的方法。

String s = t.toString();	// s = "500",t是类，有toString方法
String s1 = Integer.toString(314);	// s1 = "314" 将数字转换成字符串。
String s2 = "4.56";
double ds = Double.parseDouble(s2);		// 将字符串转换成数字
  • 拆箱：将数字包装类中内容变为基本数据类型。 
int j = t.intValue();	// j = 500, intValue取出包装类中的数据
  • 包装类在实际开发中用的最多的在于字符串变为基本数据类型。 
String str1 = "30";
String str2 = "30.3";
int x = Integer.parseInt(str1);		// 将字符串变为int型
float f = Float.parseFloat(str2);	// 将字符串变为int型
avatar
文章
阅读
粉丝