22.面向对象特征之二: 继 承
01.多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么子类无需再定义这些属性和行为,只要继承父类即可。
02.定义方法:
//定义父类
public class Person {
public String name;
public int age;
public String getInfo() {...}
}
//使用extends关键字定义继承的子类,意即对父类的"扩展".
public class Student extends Person{
public String school;
}
//Student类继承了父类Person的所有属性和方法,并增加了一个属性school.
//Person中的属性和方法,Student都可以利用.
//如果子类和父类不在同一个包下,子类只能使用父类中public和protected修饰的成员
03.继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系,提供了多态的前提。
不要仅为了获取其他类中某个功能而去继承,继承的类之间应该有逻辑性
子类不能直接访问父类中私有的(private)的成员变量和方法,应通过setter、getter方法访问
04.一个子类只能有一个父类,一个父类可以派生出多个子类,Java支持多层继承,但不支持一个子类多个父类这样的 多重继承
05.方法的重写(override)
(1).在子类中可以根据需要对从父类中继承来的方法进行改造,子类的方法将覆盖父类的方法,称重写。
(2).方法重写时的注意:
a.重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。
b.重写方法不能使用比被重写方法更严格的访问权限。
c.重写和被重写的方法须同时为static的,或同时为非static的
d.子类方法抛出的异常不能大于父类被重写方法的异常
(3).重写示例代码:
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 + "\nage: "+ age
+ "\nschool: "+ school;
}
}
(4).在eclipse中可以使用快捷键 Alt+/ 选择override进行快速重写。
23.关键字super
01.super可用于访问父类中定义的属性,方法,以及父类的构造函数.
02. a.尤其当子父类出现同名成员时,可以用super进行区分
b.super的追溯不仅限于直接父类,还可以调用子类之上的所有父类
c.super和this的用法相像,this代表本类对象的引用,super代表父类的内存空间的标识
03.使用方法:可以使用 super.+父类成员 进行调用。
04.注意:
a.子类中所有的构造器默认都会访问父类中空参数的构造器
b.当父类中没有空参数的构造器时,子类的构造器必须通过this(参数列表)或者super(参数列表)语 句指定调用本类或者父类中相应的构造器,且必须放在构造器的第一行
c.如果子类构造器中既未显式调用父类或本类的构造器,且父类中又没有无参的构造器,则编译出错
代码示例:
//父类
1 public class Person {
2
3 private String name;
4 private int age;
5 private Date birthDate;
6
7 public Person(String name, int age, Date d) {
8 this.name = name;
9 this.age = age;
10 this.birthDate = d;
11 }
12 public Person(String name, int age) {
13 this(name, age, null);
14 }
15 public Person(String name, Date d) {
16 this(name, 30, d);
17 }
18 public Person(String name) {
19 this(name, 30);
20 }
21
22 }//调用父类
1 public class Student extends Person {
2 private String school;
3
4 public Student(String name, int age, String s) {
5 super(name, age);
6 school = s;
7 }
8 public Student(String name, String s) {
9 super(name);
10 school = s;
11 }
12 public Student(String s) { // 编译出错: no super(),系统将调用父类
无参数的构造方法。
13 school = s;
14 }
15 }
24.this和super的区别
25.面向对象的特征之三:多态性
(1)Java中多态性的两种体现:
01.方法的重载(overload)和重写(overwrite).
a.重载:本类中允许同名方法存在,体现相同的方法实现不同的逻辑
b.重写:子类对父类方法的覆盖,子类可以使用和父类相同的方法名,覆盖掉父类的逻辑
02.对象的多态性 --子类的对象可以替代父类的对象使用,可以直接应用在抽象类和接口上.
03.Java引用变量有两个类型:
编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。若编译时类型和运行时类型不一致,就出现多态(Polymorphism)
(2)对象的多态性:
01.一个变量只能有一种确定的数据类型,但一个引用类型变量可能指向(引用)多种不同类型的对象
示例:
Person p = new Person();
Person e = new Student(); // Person类型的变量e,指向Student类型的对象
02.子类可看做是特殊的父类,所以父类类型的引用可以指向子类的对象:向上转型(upcasting).
即子类的对象可以给父类类型的变量作为引用
03.一个引用类型变量如果声明为父类的类型,但实际引用的是子类对象,
那么该变量就不能再访问子类中添加的属性和方法
示例:
Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量
//属性是在编译时确定的,编译时e为Person类型,没有school成员变量,因而编译错误。
04.虚拟方法调用
//正常的方法调用
Person p = new Person();
p.getInfo();
Student s = new Student();
s.getInfo();
//虚拟方法调用(多态情况下)
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法
//编译时类型和运行时类型编译时e为Person类型,而方法的调用是在运行时确定的,所以调用的是Student类的getInfo()方法。
//Java的方法是运行在栈内存中的,在运行方法时会动态进栈和出栈--动态绑定.
(3)多态小结:
前提:
需要存在继承或者实现关系
要有覆盖操作
成员方法:
编译时:要查看引用变量所属的类中是否有所调用的方法.
运行时:调用实际对象所属的类中的重写方法.
成员方法的多态性,也就是多态绑定,必须在有方法的重写前提下才能进行.
成员变量:
不具备多态性,只看引用变量所属的类.
26.instanceof操作符
01.x instanceof A:检验x是否为类A的对象,返回值为boolean型.
02.要求x所属的类与类A必须是子类和父类的关系,否则编译错误.
03.如果x属于类A的子类B,x instanceof A值也为true.
27.Object类
01.Object类是所有Java类的根父类(基类).
在多层继承中处于最高层的父类一定是Object类
02.如果在类的声明中未使用extends关键字指明其父类,则默认父类为Object类
public class Person {
...
}
//等价于:
public class Person extends Object {
...
}
03.可以用于接收作为参数的类.
//示例:
method(Object obj){…}//可以接收任何类作为其参数
Person o=new Person();
method(o);
04.Object类中的方法
Object是所有类的父类,子类可以调用父类的方法,所以Object中的方法在其他所有类中都可以使用 对象.方法()
方法列表:
num | 方法 | 类型 | 描述 |
a | public Object() | 构造 | 构造方法 |
b | public boolean equals(Object obj) | 普通 | 对象比较 |
c | public int hashCode() | 普通 | 取得Hash码 |
d | public String toString() | 普通 | 对象打印时调用 |
28.对象类型转换(Casting)
01.对Java对象的强制类型转换称为造型
a.从子类到父类的类型转换可以自动进行
b.从父类到子类的类型转换必须通过造型(强制类型转换)实现
c.无继承关系的引用类型间的转换是非法的
d.String类是Object类的子类,所以也满足上面的法则
对象类型转换代码示例:
public class Test{
public void method(Person e){ //设Person类中没有getschool() 方法
// System.out.pritnln(e.getschool()); //非法,编译时错误,因为e在形参传入时是Person类的对象,没有.getschool()方法,应该进行判断和转换
if(e instanceof Student){
Student me = (Student)e; //将e强制转换为Student类型
System.out.pritnln(me.getschool());
}
}
public static void main(Stirng args[]){
Test t = new Test();
Student m = new Student();
t.method(m);
}
}
29.==操作符与equals方法
01. ==操作符
a.基本类型比较值:只要两个变量的值相等,即为true.
b.引用类型比较引用(是否指向同一个对象):只有指向同一个对象时(在内存中的地址),==才返回true.
c.用“==”进行比较时,符号两边的数据类型必须兼容(可自动转换的基本数据类型除外),否则编译出错.
02.equals()方法
a.所有类都继承了Object,也就获得了equals()方法。还可以重写.
b.只能比较引用类型,其作用与“==”相同,比较是否指向同一个对象(地址)
c.调用格式:obj1.equals(obj2)
d.特例:当用equals()方法进行比较时,对类File、String、Date及包装类来说,因为在这些类中重写了Object类的equals()方法,所以比较的是类型及内容,而不是引用的是否是同一个对象.
30.String对象的创建
31.toString()方法
01.toString()方法在Object类中定义,其返回值是String类型,返回类名和它的引用地址。
02.打印对象时,默认输出对象的内存地址,即输出 对象.toString()
32.包装类(Wrapper)
01.针对八种基本定义相应的引用类型—包装类(封装类)
02.基本数据类的包装类主要用于基本数据类型与字符串之间的转换
03.基本数据类型的实例化转为对应的包装类后,就有了类的特点,就可以调用类中的方法。
基础数据类型对应包装类列表
基本数据类型 | 包装类 |
boolean | Boolean |
byte | Byte |
short | Short |
int | Integer |
long | Long |
char | Character |
float | Float |
double | Double |
04.基本数据类型包装成包装类 ---装箱
//通过包装类的构造器实现:
int i = 500; Integer t = new Integer(i);
//还可以通过字符串参数构造包装类对象:
Float f = new Float(“4.56”);
05.获得包装类对象中包装的基本类型变量 ---拆箱
//调用包装类的.xxxValue()方法:
boolean b = bObj.booleanValue();
06.JDK1.5之后,支持自动装箱,自动拆箱。但类型必须匹配。
07.使用包装类进行字符串与基本数据类型之间的转换.
a.字符串转换成基本数据类型
//通过包装类的构造器实现:
int i = new Integer(“12”);
//通过包装类的parseXxx(String s)静态方法:
Float f = Float.parseFloat(“12.1”);b.基本数据类型转换成字符串
//调用字符串重载的valueOf()方法:
String fstr = String.valueOf(2.34f);
//更直接的方式:
String intStr = 5 + “”;下节传送门:《JAVA SE学习笔记(六):面向对象编程-c》