4.1 面向对象特征之二:继承
为描述和处理个人信息,定义类Person:
public class Person {
public String name;
public int age;
public Date birthDate;
public String getInfo(){...}
}
为描述和处理学生信息,定义类Student:
public class Student {
public String name;
public int age;
public Date birthDate;
public String school;
public String getInfo(){...}
}
通过继承,简化Student类的定义:
public class Person {
public String name;
public int age;
public Date birthDate;
public String getInfo() {...}
}
//Student类继承了父类Person的所有属性和方法并增加了一个属性school。
//Person中的属性和方法,Student都可以利用。
public class Student extends Person{
public String school;
}
为什么要有继承?
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
此处的多个类称为子类,单独的这个类称为父类(基类或超类)。
类继承语法规则:
class Subclass extends Superclass{ }
继承的作用:
- 继承的出现提高了代码的复用性。
- 继承的出现让类与类之间产生了关系,提供了多态的前提。
- 不要仅为了获取其他类中某个功能而去继承。
关于继承的说明:
- 子类继承了父类,就继承了父类的方法和属性。
- 在子类中,可使用父类中定义的方法和属性,也可创建新的数据和方法。
- 在Java中,继承的关键字用的是extends,即子类不是父类的子集而是对父类的扩展。
关于继承的规则:
- 子类不能直接访问父类中私有的(private)的成员变量和方法。
单继承举例
Java 只支持单继承,不允许多重继承。
- 一个子类只能有一个父类
- 一个父类可以派生出多个子类
class SubDemo extends Demo{ } //ok
class SubDemo extends Demo1,Demo2{ } //error
练习
(1)定义一个ManKind类,包括成员变量int sex和int salary;
方法void manOrWorman():根据sex的值显示“man”(sex==1)或者“women”(sex==0);方法void employeed():根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。
(2)定义类Kids继承ManKind,并包括成员变量int yearsOld;方法printAge()打印yearsOld的值。
(3)在Kids类的main方法中实例化Kids的对象someKid,用该对象访问其父类的成员变量及方法。
class ManKind {
int sex;
int salary;
void manOrWorman() {
if (sex == 1) {
System.out.println("man");
} else if (sex == 0) {
System.out.println("women");
}
}
void employeed() {
if (salary == 0) {
System.out.println("no job");
} else {
System.out.println("job");
}
}
}
class Kids extends ManKind {
int yearsOld;
void printAge() {
System.out.println(yearsOld);
}
public static void main(String[] args) {
Kids someKid = new Kids();
someKid.sex = 1;
someKid.salary = 1;
someKid.yearsOld = 12;
someKid.manOrWorman();
someKid.employeed();
someKid.printAge();
}
}
练习
定义一个学生类Student,它继承自Person类。
class Person {
String name;
String sex;
int age;
public Person(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
}
class Student extends Person {
long number;
int math;
int english;
int computer;
public Student(String n, String s, int a,
long k, int m, int e, int c) {
super(n, s, a);
number = k;
math = m;
english = e;
computer = c;
}
double aver() {
return (math + english + computer) / 3;
}
int max() {
int max = math > english ? math : english;
max = max > computer ? max : computer;
return max;
}
int min() {
int min = math < english ? math : english;
min = min < computer ? min : computer;
return min;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", number=" + number +
", math=" + math +
", english=" + english +
", computer=" + computer +
'}';
}
}
public class Test {
public static void main(String[] args) {
Student stu = new Student("张三","男",20,101,98,88,90);
System.out.println(stu);
}
}
练习
根据下图实现类。在TestCylinder类中创建Cylinder类的对象,设置圆柱的底面半径和高,并输出圆柱的体积。
class Circle {
private double radius;
public Circle() {
radius = 1;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public double findArea() {
return Math.PI * radius * radius;
}
}
class Cylinder extends Circle {
private double length;
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public double findVolume() {
return super.findArea() * length;
}
}
public class TestCylinder {
public static void main(String[] args) {
Cylinder c = new Cylinder();
c.setRadius(2);
System.out.println("面积是:"+ c.findArea());
c.setLength(3);
System.out.println("体积是:"+ c.findVolume());
}
}
4.2 方法的重写(override)
定义
在子类中可以根据需要对从父类中继承来的方法进行改造,也称方法的重置、覆盖。在程序执行时,子类的方法将覆盖父类的方法。
要求:
- 重写方法必须和被重写方法具有相同的方法名、参数列表和返回值类型。
- 重写方法不能使用比被重写方法更严格的访问权限。
- 重写和被重写的方法须同时为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 + "\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();
p1.getInfo();
//调用Person类的getInfo()方法
Student s1=new Student();
s1.getInfo();
//调用Student类的getInfo()方法
这是一种“多态性”:同名的方法,用不同的对象来区分调用的是哪一个方法。
重写方法举例(2)
class Parent {
public void method1() {}
}
class Child extends Parent {
private void method1() {}
//非法,子类中的method1()的访问权限private比被覆盖方法的访问权限public弱
}
public class UseBoth {
public static void main(String[] args) {
Parent p1 = new Parent();
Child p2 = new Child();
p1.method1();
p2.method1();
}
}
练习
如果现在父类的一个方法定义成private访问权限,在子类中将此方法声明为default访问权限,那么这样还叫重写吗?(NO)
修改练习1.1中定义的类Kids,在Kids中重新定义employed()方法,覆盖父类ManKind中定义的employed()方法,输出“Kids should study and no job.”
class Kids extends ManKind {
//...
void employeed(){
System.out.println("Kids should study and no job.");
}
//...
}
4.3 四种访问权限修饰符
Java权限修饰符public、protected、private置于类的成员定义前,用来限定对象对该类对象成员的访问权限。
对于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.4 关键字super
在Java类中使用super来调用父类中的指定操作:
- super可用于访问父类中定义的属性
- super可用于调用父类中定义的成员方法
- super可用于在子类构造方法中调用父类的构造器
注意:
- 尤其当子父类出现同名成员时,可以用super进行区分
- super的追溯不仅限于直接父类
- super和this的用法相像,this代表本类对象的引用,super代表父类的内存空间的标识
关键字super举例
class Person {
protected String name="张三";
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 TestStudent{
public static void main(String[] args){
Student st = new Student();
System.out.println(st.getInfo());
}
}
练习
1.修改练习1.1中定义的类Kids中employed()方法,在该方法中调用父类ManKind的employed()方法,然后再输出“but Kids should study and no job.”
class Kids extends ManKind {
//...
void employeed(){
super.employeed();
System.out.println("Kids should study and no job.");
}
//...
2.修改练习1.3中定义的Cylinder类,在Cylinder类中覆盖findArea()方法,计算圆柱的表面积。考虑:findVolume方法怎样做相应的修改?在TestCylinder类中创建Cylinder类的对象,设置圆柱的底面半径和高,并输出圆柱的表面积和体积。
附加题:在TestCylinder类中创建一个Circle类的对象,设置圆的半径,计算输出圆的面积。体会父类和子类成员的分别调用。
调用父类的构造器
- 子类中所有的构造器默认都会访问父类中空参数的构造器
- 当父类中没有空参数的构造器时,子类的构造器必须通过**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;
}
public Student(String s) {
// 编译出错: no super(),
// 系统将调用父类无参数的构造方法。
school = s;
}
}
this和super的区别
4.5 子类对象实例化过程
思考:
- 为什么super(…)和this(…)调用语句不能同时在一个构造器中出现?
- 为什么super(…)或this(…)调用语句只能作为构造器中的第一句出现?
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();
}
}
练习
修改练习1.3中定义的Circle类和Cylinder类的构造器,利用构造器参数为对象的所有属性赋初值。
4.6 面向对象特征之三:多态
多态性,是面向对象中最重要的概念,在Java中有两种体现:
- 方法的重载(overload)和重写(overwrite)。
- 对象的多态性 ——可以直接应用在抽象类和接口上。
Java引用变量有两个类型:编译时类型和运行时类型。
- 编译时类型由声明该变量时使用的类型决定。
- 运行时类型由实际赋给该变量的对象决定。
若编译时类型和运行时类型不一致,就出现多态。
对象的多态 —在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成员变量,因而编译错误。
### 虚拟方法调用(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()方法。——动态绑定
### 多态小结
前提:
- 需要存在继承或者实现关系
- 要有覆盖操作
成员方法:
- 编译时:要查看引用变量所属的类中是否有所调用的方法。
- 运行时:调用实际对象所属的类中的重写方法
成员变量:
- 不具备多态性,只看引用变量所属的类。
### 练习:继承成员变量和继承方法的区别
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 TestFieldMethod { 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(); } }
子类继承父类
- 若子类重写了父类方法,就意味着子类里定义的方法彻底覆盖了父类里的同名方法,系统将不可能把父类里的方法转移到子类中
- 对于实例变量则不存在这样的现象,即使子类里定义了与父类完全相同的实例变量,这个实例变量依然不可能覆盖父类中定义的实例变量
### 多态性应用举例
方法声明的形参类型为父类类型,可以使用子类的对象作为实参调用该方法。
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 } }
### 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类及其子类对象 }
### 练习
> 建立TestInstance 类,在类中定义方法method1(Person e);
在method1中:
(1)根据e的类型调用相应类的getInfo()方法。
(2)根据e的类型执行:
如果e为Person类的对象,输出:“a person”;
如果e为Student类的对象,输出
“a student”
“a person ”
如果e为Graduate类的对象,输出:
“a graduated student”
“a student”
“a person”
class Person { protected String name="person"; protected int age=50; public String getInfo() { return "Name: "+ name + "\n" +"age: "+ age; } } class Student extends Person { protected String school="pku"; public String getInfo() { return "Name: "+ name + "\nage: "+ age + "\nschool: "+ school; } } class Graduate extends Student{ public String major="IT"; public String getInfo() { return "Name: "+ name + "\nage: "+ age + "\nschool: "+ school+"\nmajor:"+major; } }
### 对象类型转换 (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.pritnln(e.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); } }
![](https://upload-images.jianshu.io/upload_images/13516495-8b05b630d105800e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
# 4.7 Object类、包装类
- Object类是所有Java类的根父类
- 如果在类的声明中未使用extends关键字指明其父类,则默认父类为Object类
public class Person { ... } 等价于: public class Person extends Object { ... }
例:
method(Object obj){…}//可以接收任何类作为其参数 Person o=new Person();
method(o);
### Object类中的主要方法
![](https://upload-images.jianshu.io/upload_images/13516495-c663e45e88dbd32d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
### 关于==
基本类型比较值:只要两个变量的值相等,即为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()方法。
### 练习
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.sql.Date()); //编译不通过
### 练习
Person p1 = new Person(); p1.name = "atguigu";
Person p2 = new Person(); p2.name = "atguigu";
System.out.println(p1.name .equals( p2.name));//true System.out.println(p1.name == p2.name);//true System.out.println(p1.name == "atguigu");
String s1 = new String("bcde"); String s2 = new String("bcde"); System.out.println(s1==s2);//false
![](https://upload-images.jianshu.io/upload_images/13516495-649418cb1fca6dc3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
### 练习
> 1.编写Order类,有int型的orderId,String型的OrderName,相应的getter()和setter()方法,两个参数的构造器,重写父类的equals()方法:public boolean equals(Object obj),并判断测试类中创建的两个对象是否相等。
> 2.请根据以下代码自行定义能满足需要的MyDate类,在MyDate类中覆盖equals方法,使其判断当两个MyDate类型对象的年月日都相同时,结果为true,否则为false。 public boolean equals(Object o)
class TestEquals { public static void main(String[] args) { MyDate m1 = new MyDate(14, 3, 1976); MyDate m2 = new MyDate(14, 3, 1976); if (m1 == m2) { System.out.println("m1==m2"); } else { System.out.println("m1!=m2"); //m1 != m2 } if (m1.equals(m2)) { System.out.println("m1 is equal to m2"); // m1 is equal to m2 } else { System.out.println("m1 is not equal to m2"); } } }
### toString() 方法
- toString()方法在Object类中定义,其返回值是String类型,返回类名和它的引用地址。
- 在进行String与其它类型数据的连接操作时,自动调用toString()方法。
Date now=new Date(); System.out.println(“now=”+now);
// 相当于 System.out.println(“now=”+now.toString());
- 可以根据需要在用户自定义类型中重写toString()方法
- 基本类型数据转换为String类型时,调用了对应包装类的toString()方法。
int a=10;
System.out.println(“a=”+a);
### 练习
> 定义两个类,父类GeometricObject代表几何形状,子类Circle代表圆形。
![](https://upload-images.jianshu.io/upload_images/13516495-947c43b967c0f74c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
![](https://upload-images.jianshu.io/upload_images/13516495-649c50a1dd5208e3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
> 写一个测试类,创建两个Circle对象,判断其颜色是否相等;利用equals方法判断其半径是否相等;利用toString()方法输出其半径。
### 包装类(Wrapper)
- 针对八种基本定义相应的引用类型—包装类(封装类)
- 有了类的特点,就可以调用类中的方法。
![](https://upload-images.jianshu.io/upload_images/13516495-3a0f0bfd01470ed6.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
- 基本数据类型包装成包装类的实例——装箱
通过包装类的构造器实现:
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之后,支持自动装箱,自动拆箱。但类型必须匹配。
- 字符串转换成基本数据类型
通过包装类的构造器实现:
int i = new Integer(“12”);
通过包装类的parseXxx(String s)静态方法:
Float f = Float.parseFloat(“12.1”);
- 基本数据类型转换成字符串
调用字符串重载的valueOf()方法:
String fstr = String.valueOf(2.34f);
更直接的方式:
String intStr = 5 + "" ;
### 包装类用法举例
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型
### 练习
> 利用Vector代替数组处理:从键盘读入学生成绩(以负数代表输入结束),找出最高分,并输出学生成绩等级。
提示:数组一旦创建,长度就固定不变,所以在创建数组前就需要知道它的长度。而向量类java.util.Vector可以根据需要动态伸缩。
创建Vector对象:Vector v=new Vector();
给向量添加元素:v.addElement(obj); //obj必须是对象
取出向量中的元素:Object obj=v.elementAt(0);
注意第一个元素的下标是0,返回值是Object类型的。
计算向量的长度:v.size();
若与最高分相差10分内:A等;20分内:B等;
30分内:C等;其它:D等