第二章 Java基本语法 讲师：复凡

本章内容 4.1 面向对象特征之二：继承 4.2 方法的重写(override) 4.3 四种访问权限修饰符 4.4 关键字super 4.1 面向对象特征之二：继承 4.2 方法的重写(override) 4.3 四种访问权限修饰符 4.4 关键字super 4.5 子类对象实例化过程 4.6 面向对象特征之三：多态 4.7 Object类、包装类

4.1 面向对象特征之二：继承 为描述和处理个人信息，定义类Person: public class Person { 4.1 面向对象特征之二：继承 为描述和处理个人信息，定义类Person: public class Person { public String name; public int age; public Date birthDate; public String getInfo() {...} } Person +name : String +age : int +birthDate : Date +getInfo() : String

继 承(1) 为描述和处理学生信息，定义类Student: public class Student { 继 承(1) 为描述和处理学生信息，定义类Student: public class Student { public String name; public int age; public Date birthDate; public String school; public String getInfo() {...} } Student +name : String +age : int +birthDate : Date +school : String +getInfo() : String

Person类 通过类的继承 Farmer类 Student类 Worker类 Teacher类

人类 通过继承的方式实现 特有的代码 特有的代码 特有的代码 特有的代码 工人类 学生类 教师类 农民类

继 承(2) 通过继承，简化Student类的定义: public class Person { public String name; 继 承(2) 通过继承，简化Student类的定义: public class Person { public String name; public int age; public Date birthDate; public String getInfo() {...} } public class Student extends Person{ public String school; //Student类继承了父类Person的所有属性和方法，并增加了一个属性school。Person中的属性和方法,Student都可以利用。 Person +name : String +age : int +birthDate : Date +getInfo() : String Student +school : String

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

继 承(4) 作用： 继承的出现提高了代码的复用性。 继承的出现让类与类之间产生了关系，提供了多态的前提。 继 承(4) 作用： 继承的出现提高了代码的复用性。 继承的出现让类与类之间产生了关系，提供了多态的前提。 不要仅为了获取其他类中某个功能而去继承

类的继承 (5) 子类继承了父类，就继承了父类的方法和属性。 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。 关于继承的规则： 子类不能直接访问父类中私有的(private)的成员变量和方法。

单继承举例 superclass subclass subsubclass Person +name : String +age : int +birthDate : Date +getInfo() : String superclass subclass Soldier Student +school : String Officer Graduate +major : String +register() : void subsubclass

类的继承 (6) Java只支持单继承，不允许多重继承 一个子类只能有一个父类 一个父类可以派生出多个子类 class SubDemo extends Demo{ } //ok class SubDemo extends Demo1,Demo2...//error 多重继承 多层继承

练习1 1.(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，用该对象访问其父类的成员变量及方法。

练习1 Person #name: String #sex:char #age:int 2.定义一个学生类Student，它继承自Person类 Person #name: String #sex:char #age:int +Person(name:String sex:char age:int) +toString():String Student number:long int:math int:english int:computer +Student(n:String s:char a:int k:long m:int e:int c:int) +aver():double +max():int +min():int +toString():String

练习1 3.根据下图实现类。在TestCylinder类中创建Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱的体积。 Circle (圆) -radius :double Circle(): 构造方法,将radius属性初始化为1 +setRadius(double radius) : void +getRadius(): double +findArea():double 计算圆的面积 Cylinder (圆柱) -length:double Cylinder(): 构造方法,将length属性初始化为1 +setLength(double length):void +getLength():double +findVolume() :double 计算圆柱体积

4.2 方法的重写(override) 定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。 要求： 重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。 重写方法不能使用比被重写方法更严格的访问权限。 重写和被重写的方法须同时为static的，或同时为非static的 子类方法抛出的异常不能大于父类被重写方法的异常

重写方法举例(1) Person p1=new Person(); p1.getInfo(); 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();

练习2 1.如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？(NO) 2. 修改练习1.1中定义的类Kids，在Kids中重新定义employed()方法，覆盖父类ManKind中定义的employed()方法，输出“Kids should study and no job.”

4.3 四种访问权限修饰符 Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类对象成员的访问权限。 修饰符 类内部 同一个包 子类 任何地方 private Yes default protected public 对于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() }

访问控制分析 父类Parent和子类Child在同一包中定义时： 子类对象可以访问的数据 子类的对象可以调用的方法 f2_default fm2()_default f3_protected fm3()_ protected f4_public fm4()_ public c1_private cm1()_private c2_public cm2()_public 子类对象可以访问的数据 子类的对象可以调用的方法

在Java类中使用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; } return super.getInfo() +"\nschool: " +school; public class TestStudent{ public static void main(String[] args){ Student st = new Student(); System.out.println(st.getInfo());

练习3 1.修改练习1.1中定义的类Kids中employed()方法，在该方法中调用父类ManKind的employed()方法，然后再输出“but Kids should study and no job.” 2.修改练习1.3中定义的Cylinder类，在Cylinder类中覆盖findArea()方法，计算圆柱的表面积。考虑：findVolume方法怎样做相应的修改？ 在TestCylinder类中创建Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱的表面积和体积。 附加题：在TestCylinder类中创建一个Circle类的对象，设置圆的半径，计算输出圆的面积。体会父类和子类成员的分别调用。

调用父类的构造器 子类中所有的构造器默认都会访问父类中空参数的构造器 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

调用父类构造器举例 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 }

this和super的区别 No. 区别点 this super 1 访问属性 访问本类中的属性，如果本类没有此属性则从父类中继续查找 访问父类中的属性 2 调用方法 访问本类中的方法 直接访问父类中的方法 3 调用构造器 调用本类构造器，必须放在构造器的首行 调用父类构造器，必须放在子类构造器的首行 4 特殊 表示当前对象 无此概念

4.6 面向对象特征之三：多态性 多态性，是面向对象中最重要的概念，在java中有两种体现： 4.6 面向对象特征之三：多态性 多态性，是面向对象中最重要的概念，在java中有两种体现： 方法的重载(overload)和重写(overwrite)。 对象的多态性 ——可以直接应用在抽象类和接口上。 Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。 若编译时类型和运行时类型不一致，就出现多态（Polymorphism）

多态性(2) 对象的多态 —在Java中,子类的对象可以替代父类的对象使用 一个变量只能有一种确定的数据类型 一个引用类型变量可能指向(引用)多种不同类型的对象 Person p = new Student(); Object o = new Person();//Object类型的变量o，指向Person类型的对象 o = new Student(); //Object类型的变量o，指向Student类型的对象 子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

多态性(3) 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法 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(); 虚拟方法调用(多态情况下) 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 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) {//Person e = m; //…… 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的子类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类及其子类对象 }

练习5 建立TestInstance 类，在类中定义方法method1(Person e); 在method1中: 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"; return "Name: "+ name + "\nage: "+ age + "\nschool: "+ school; class Graduate extends Student{ public String major="IT"; public String getInfo() { + "\nschool: "+ school+"\nmajor:"+major; 建立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 person”

对象类型转换 (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);

父类（如：Person） 较高级的基本数据类型 强制类型转化 自动类型转化 向下转型 向上转型 使用instanceof进行判断 较低级的基本数据类型 子类（如：Student）

4.7 Object 类 Object类是所有Java类的根父类 如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类 public class Animal extengs Object(){} public class Person extends Animal{ ... } 等价于： public class Person extends Object { 例：method(Object obj){…}//可以接收任何类作为其参数 Person o=new Person(); method(o);

Object类中的主要方法 NO. 方法名称 类型 描述 public Object() 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){…} 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()方法。

练 习 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 = “abc"; System.out.println(p1.name .equals( p2.name));//true System.out.println(p1.name == p2.name);//true System.out.println(p1.name == “abc"); String s1 = new String("bcde"); String s2 = new String("bcde"); System.out.println(s1==s2);//false

练 习6 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)

toString() 方法 toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。 Date now=new Date(); System.out.println(“now=”+now); 相当于 System.out.println(“now=”+now.toString()); 可以根据需要在用户自定义类型中重写toString()方法 如String 类重写了toString()方法，返回字符串的值。 s1=“hello”; System.out.println(s1);//相当于System.out.println(s1.toString()); 基本类型数据转换为String类型时，调用了对应包装类的toString()方法 int a=10; System.out.println(“a=”+a);

4.7 包装类(Wrapper) 针对八种基本定义相应的引用类型—包装类（封装类） 有了类的特点，就可以调用类中的方法。 基本数据类型 boolean Boolean byte Byte short Short int Integer long Long char Character float Float double Double

基本数据类型包装成包装类的实例 ---装箱 通过包装类的构造器实现： 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型

0512-57882866 www.bcdaren.com 昆山爱达人 1250121864 昆山爱达人信息技术有限公司 视频录制： 视频提供 视频录制： 联系电话： 0512-57882866 官网地址： www.bcdaren.com 联系公众号： 昆山爱达人 联系QQ： 1250121864 编程达人APP: