[TOC]

java-面向对象

继承性(inheritance)

  • 为什么要有继承？
  • 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
  • 此处的多个类称为子类(派生类)， 单独的这个类称为父类(基类或超类)。 可以理解为:“子类 is a 父类”
  • 类继承语法规则: class Subclass extends SuperClass{ }

作用：

  • 继承的出现减少了代码冗余，提高了代码的复用性。

  • 继承的出现，更有利于功能的扩展。

  • 继承的出现让类与类之间产生了关系，提供了多态的前提。

  • ==注意：不要仅为了获取其他类中某个功能而去继承==

  • 子类继承了父类，就继承了父类的方法和属性。

  • 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。

  • 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展” 。

关于继承的规则：子类不能直接访问父类中私有的(private)的成员变量和方法。

Java只支持单继承和多层继承， 不允许多重继承**

  • 一个子类只能有一个父类
    • 一个父类可以派生出多个子类
      • class SubDemo extends Demo{ } //ok
      • class SubDemo extends Demo1,Demo2…//error

方法的重写(override/overwrite)

定义：

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

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

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

    1. 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
    2. 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
    3. 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)

  3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限

    • 子类不能重写父类中声明为private权限的方法

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

    注意：

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Person { 
    public String name; public int age; //重写方法举例(1)
	public String getInfo() {
	return "Name: "+ name + "\n" +"age: "+ age;
		}
}
public class Student extends Person {
	public String school;
	public String getInfo() { //重写方法
	return "Name: "+ name + "\nage: "+ age+ "\nschool: "+ 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();
//这是一种“多态性”：同名的方法，用不同的对象来区分调用的是哪一个方法。

方法的重载与重写 （总结）

​ 重载，是指允许存在多个同名方法，而这些方法的参数不同。 编译器根据方法不同的参数表， 对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。 它们的调用地址在编译期就绑定了。 Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。

​ 所以： 对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定” ；

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

引用一句Bruce Eckel的话： “不要犯傻，如果它不是晚绑定， 它就不是多态。”

关键字—super

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

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

注意：

  1. 尤其当子父类出现同名成员时， 可以用super表明调用的是父类中的成员
  2. super的追溯不仅限于直接父类
  3. super和this的用法相像， this代表本类对象的引用， super代表父类的内存空间的标识 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class protected Person {
    String name = "张三"; //关键字super举例
	protected int age;
	public String getInfo() {
	return "Name: " + name + "\nage: " + age;
		}
}
class Student extends Person {
	protected String name = "李四";
	private String school = "New Oriental";
	public String getSchool() {
	return school;
			}
	public String getInfo() {
	return super.getInfo() + "\nschool: " + school;
			}}
	public class StudentTest {
	public static void main(String[] args) {
	Student st = new Student();
	System.out.println(st.getInfo());
		}
}

调用父类的构造器

子类中所有的构造器默认都会访问父类中空参数的构造器

  • 当父类中没有空参数的构造器时， 子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。 同时， 只能”二选一”， 且必须放在构造器的首行
  • 如果子类构造器中既未显式调用父类或本类的构造器， 且父类中又没有无参的构造器， ==则编译出错== 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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的区别

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

子类对象的实例化过程

43121.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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();
}}

super 关键字-小结

可以理解为：父类的,可以用来调用的结构：属性、方法、构造器

super调用属性、方法：
  1. 我们可以在子类的方法或构造器中。通过使用”super.属性”或”super.方法”的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略”super.”
  2. 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用”super.属性”的方式，表明调用的是父类中声明的属性。
  3. 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用”super.方法”的方式，表明调用的是父类中被重写的方法。
super调用构造器：
  1. 我们可以在子类的构造器中显式的使用”super(形参列表)”的方式，调用父类中声明的指定的构造器
  2. “super(形参列表)”的使用，必须声明在子类构造器的首行！
  3. 我们在类的构造器中，针对于”this(形参列表)”或”super(形参列表)”只能二一，不能同时出现
  4. 在构造器的首行，没显式的声明”this(形参列表)”或”super(形参列表)”，则默认调用的是父类中空参的构造器:super()
  5. 在类的多个构造器中，至少一个类的构造器中使用了”super(形参列表)”，调用父类中的构造器

多态性

多态解释

多态性，是面向对象中最重要的概念， 在Java中的体现：
==对象的多态性：父类的引用指向子类的对象==

可以直接应用在抽象类和接口上

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

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

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

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

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

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

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

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

1
2
3
4
Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量

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

方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法 

1
2
3
4
5
6
7
8
9
10
11
public class Test {
	public void method(Person e) {
	// ……
	e.getInfo();
	}
	public static void main(Stirng args[]) {
	Test t = new Test();
	Student m = new Student();
	t.method(m); // 子类的对象m传送给父类类型的参数e
	}
}

虚拟方法调用(Virtual Method Invocation)

正常的方法调用

1
2
3
4
Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

1
2
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法

编译时类型和运行时类型
==编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。 ——动态绑定==

instanceof 操作符

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

  • 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
  • 如果x属于类A的子类B， x instanceof A值也为true。

对象类型转换 (Casting )

基本数据类型的Casting：

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

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

  1. 从子类到父类的类型转换可以自动进行
  2. 从父类到子类的类型转换必须通过造型(强制类型转换)实现
  3. 无继承关系的引用类型间的转换是非法的
  4. 在造型前可以使用instanceof操作符测试一个对象的类型 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test {
	public void method(Person e) { // 设Person类中没有getschool() 方法
	// System.out.pritnln(e.getschool()); //非法,编译时错误
	if (e instanceof Student) {
		Student me = (Student) e; // 将e强制转换为Student类型
		System.out.pritnln(me.getschool());
	}
}
	public static void main(String[] args){
		Test t = new Test();
		Student m = new Student();
		t.method(m);
	}
}

1151312.png

子类继承父类

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

多态小结

多态作用：

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

前提：

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

成员方法：

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

成员变量：

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

Object 类的使用

Object类中的主要结构

NO. 方法名称 类型 描述
1 public Object() 构造 构造器
2 public boolean equals(Object obj) 普通 对象比较
3 public int hashCode() 普通 取得Hash码
4 public String toString() 普通 对象打印时调用

==操作符与equals方法

= =：

基本类型比较值:只要两个变量的值相等， 即为true。
int a=5; if(a==6){…}
引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时， == 才返回true。

1
2
3
Person p1=new Person();
Person p2=new Person();
if (p1== p2){…}

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

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

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

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

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

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

重写equals()方法的原则

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

  1. 自反性： x.equals(x)必须返回是“true” 。
  2. 传递性： 如果x.equals(y)返回是“true” ， 而且y.equals(z)返回是“true” ，那么z.equals(x)也应该返回是“true” 。
  3. 一致性： 如果x.equals(y)返回是“true” ， 只要x和y内容一直不变， 不管你重复x.equals(y)多少次， 返回都是“true” 。
  4. 任何情况下， x.equals(null)， 永远返回是“false” ；x.equals(和x不同类型的对象)永远返回是“false” 。
==和equals的区别
  1. == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
  2. equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
  3. 具体要看自定义类里有没有重写Object的equals方法来判断。
  4. 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。
练习
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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()); //编译不通过

toString() 方法

定义

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

  • 在进行String与其它类型数据的连接操作时， 自动调用toString()方法

1
2
3
Date now=new Date();
System.out.println(“now=”+now);// 相当于
System.out.println(“now=”+now.toString());
  • 可以根据需要在用户自定义类型中重写toString()方法
    如String 类重写了toString()方法， 返回字符串的值。
1
2
s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString());
  • 基本类型数据转换为String类型时， 调用了对应包装类的toString()方法
    int a=10; System.out.println(“a=”+a);
实例
1
2
3
4
5
6
7
8
public void test() {
	char[] arr = new char[] { 'a', 'b', 'c' };
	System.out.println(arr);//abc
	int[] arr1 = new int[] { 1, 2, 3 };
    System.out.println(arr1);//[I@1540e19d
    double[] arr2 = new double[] { 1.1, 2.2, 3.3 };
    System.out.println(arr2);//[D@677327b6
}

包装类的使用

定义

  1. 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
  2. 有了类的特点，就可以调用类中的方法， Java才是真正的面向对象
基本数据类型 包装类
byte Byte（父类:Number）
short Short（父类:Number）
int Integer（父类:Number）
long Long（父类:Number）
float Float（父类:Number）
double Double（父类:Number）
boolean Boolean
char Character

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

基本类型=>包装类

  • 通过包装类的构造器实现：
    ·int i = 500; Integer t = new Integer(i);·
  • 还可以通过字符串参数构造包装类对象：
    Float f = new Float(“4.56”);
    Long l = new Long(“asdf”); //NumberFormatException
  • 获得包装类对象中包装的基本类型变量 —-拆箱
    • 调用包装类的.xxxValue()方法：
      boolean b = bObj.booleanValue();
  • JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

基本类型=>String 类

  • 字符串转换成基本数据类型

    • 通过包装类的构造器实现：
      int i = new Integer(“12”);
    • 通过包装类的parseXxx(String s)静态方法：
      Float f = Float.parseFloat(“12.1”);

  • 基本数据类型转换成字符串

    • 调用字符串重载的valueOf()方法：
      String fstr = String.valueOf(2.34f);
    • 更直接的方式：
      String intStr = 5 + “”

62651.png

用法举例

1
2
3
4
5
6
7
8
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); //将字符串转换成数字

拆箱：

将数字包装类中内容变为基本数据类型。

1
2
3
4
5
6
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型

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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


public void method1() {
    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 x = 128;
    Integer y = 128;
    System.out.println(x == y);//false
}

参考：

尚硅谷_Java零基础教程-java入门必备-适合初学者的全套完整版教程(宋红康主讲)