第4章回顾 1.面向对象的三大特征：封装、继承、多态 2.类与对象的关系：类是对象的模板，对象是类的实例，类只能通过对象才可以使用。 3.类的组成：属性、方法、构造方法、代码块、内部类 4.创建对象的格式：类名称对象名称=new 类名称() 5.类属于引用数据类型。进行引用传递时，传递的是堆内存的使用权。

第4章回顾 1.面向对象的三大特征：封装、继承、多态 2.类与对象的关系：类是对象的模板，对象是类的实例，类只能通过对象才可以使用。 3.类的组成：属性、方法、构造方法、代码块、内部类 4.创建对象的格式：类名称对象名称=new 类名称() 5.类属于引用数据类型。进行引用传递时，传递的是堆内存的使用权。 6.类的封装性：通过private进行封装。原则：只要是属性，则必须全部封装。 7.构造方法。作用：为类中的属性初始化。特点：构造方法与类名称相同，无返回值类型声明。注意：每个类都至少有一个构造方法。构造方法可以重载。

第4章回顾 8.String类。赋值方式有两种。存储。比较内容使用equals()方法，比较地址使用“==” 。字符串的内容一旦声明，则不可改变。 9. this关键字。this是指向自身的一个引用。 10.static关键字。存储。由static声明的属性和方法可以由类名称直接调用。静态属性是所有对象共享的，所有对象都可以对其进行操作。 11.构造方法私有化可以限制类对象的产生数量。 12.对象数组。 13.内部类。最大优点：可以直接方便地访问外部类的私有操作。

第5章面向对象(高级篇) 5.1 类的继承 5.8 instanceof关键字 5.2 方法的覆写 5.9 抽象类与接口应用
5.3 super关键字 5.10 Object类 5.4 final关键字 5.11 包装类 5.5 抽象类 5.12 匿名内部类 5.6 接口的 5.13 StringBuffer类 5.7 对象的多态性 5.14 本章小结

5.1 类的继承 1.继承的含义生物动物鱼类植物人类猫类继承关系图
①继承关系发生在类与类之间（父类、子类） ②每个类都有自己的属性和方法。 ③子类：除继承了父类的属性和方法外，还有自己的属性和方法。在子类身上体现功能的扩展。 ④继承关系中的一个规律：子类是父类的一种。换句话说，子类就是父类。反之成立吗？

2.继承的语法和规则范例ExtDemo01.java class Person{ // 定义Person类 String name ;
int age ; public Person(){} public void speak(){ System.out.println(“Hello"); } } class Student{ // 定义Student类 String school ; // 定义school属性 public Student(){} public void speak(){ System.out.println("Hello"); } public void study(){ System.out.println(this.school); }

2.继承的语法和规则范例ExtDemo02.java class Person{ // 定义Person类 String name ;
int age ; public Person(){ } public void speak(){ System.out.println(" Hello "); class Student extends Person{ // 定义Student类,继承Person类 String school ; public Student(){ public void study(){ System.out.println(this.school);

类的继承格式：类的继承规则：子类继承父类所有的属性和方法，同时也可以在父类的基础上增加新的属性和方法。子类不继承父类的构造方法。
class 父类 { 父类语句体； } class 子类 extends 父类{ 子类语句体；类的继承格式：类的继承规则：子类继承父类所有的属性和方法，同时也可以在父类的基础上增加新的属性和方法。子类不继承父类的构造方法。每个子类只能继承一个父类，即Java仅支持单继承。

验证继承功能范例ExtDemo03.java //Person类、Student类省略，内存分析 public class ExtDemo03{ public static void main(String args[]){ Student stu = new Student(); // 实例化子类对象 System.out.println( stu.name ) ; System.out.println( stu.age ) ; System.out.println( stu.school ) ; stu.speak(); stu.study(); } 结果：⑴实现继承功能。⑵通过继承，子类可以直接把父类中的属性和方法拿到子类中使用。⑶子类同时扩展了功能。

继承的限制范例ExtDemo04.java 范例ExtDemo05.java class A{ } class B{
class C extends A,B{ 范例ExtDemo04.java class B extends A{ class C extends B{ 范例ExtDemo05.java

继承的限制虽说子类继承父类，但并不意味着子类可以直接访问父类的所有东西。父类的私有东西，子类是不能直接访问的。
范例ExtDemo06.java 子类访问限制。

class Person{ // 定义Person类
private String name ; private int age ; public Person(){} } class Student extends Person{ // 定义Student类 public void fun(){ System.out.println(“父类中的name属性：" + name); System.out.println("父类中的age属性：" + age) ;

范例ExtDemo07.java 解决方法 class Person{ // 定义Person类 private String name ;
private int age ; public String getName(){ return this.name ; } public int getAge(){ return this.age ; class Student extends Person{ // 定义Student类 public void fun(){ System.out.println("父类中的name属性：" + getName()) ; System.out.println("父类中的age属性：" + getAge()) ;

3.子类对象实例化的过程要求:子类对象在实例化时，总是先调用父类的构造方法，之后再调用自己的构造方法。
范例InstanceDemo.java 观察子类对象实例化过程。

String name ; int age ; public Person(){ System.out.println("父类的构造方法") ; } class Student extends Person{ // 定义Student类 String school ; public Student(){ System.out.println("子类的构造方法") ; public class InstanceDemo{ public static void main(String args[]){ Student stu = new Student();// 实例化子类对象

5.2 方法的覆写 class Person{ //读程序，分析子类中的方法有哪些 void print(){
System.out.println("Person --> void print()。") ; } public void fun(){ print(); } class Student extends Person{ // 定义继承关系 void print(){ System.out.println("Student --> void print()。") ; public class OverrideDemo01{ public static void main(String args[]){ new Student().fun() ;

5.2 方法的覆写方法覆写：继承关系中，在子类中定义了与父类同名的方法。方法覆写要满足的规则 ①发生在父类与子类的同名方法之间
②两个方法的参数类型、参数个数、参数顺序必须相同 ③子类方法的权限必须不小于父类方法的权限大小关系：private < default < public default:什么都不写，什么都不声明。

5.2 方法的覆写 ①方法声明 ②访问权限 class Person{ //读程序，分析子类中的方法有哪些 void print(){
System.out.println("Person --> void print()。") ; } public void fun(){ print(); } class Student extends Person{ // 定义继承关系 public void print(){ System.out.println("Student --> void print()。") ; public class OverrideDemo01{ public static void main(String args[]){ new Student().fun() ;

问题1：如果覆写的方法权限缩小，会怎样？范例OverrideDemo02.java
class Person{ // 定义父类 public void print(){ System.out.println("Person --> void print()。") ; } class Student extends Person{ // 定义继承关系 void print(){ // 降低了访问权限 System.out.println("Student --> void print()。") ;

问题2：方法覆写时，访问权限从private变为default算是方法覆写吗？范例OverrideDemo03.java

class Person{ // 定义父类 private void print(){ // 私有的访问权限 System.out.println("Person --> void print()。") ; } public void fun(){ print(); class Student extends Person{ // 定义继承关系 void print(){ // 默认的访问权限 System.out.println("Student --> void print()。") ; public class OverrideDemo03{ public static void main(String args[]){ new Student().fun();

方法重载与方法覆写的区别区别重载覆写单词 Overloading Overriding 声明方法名称相同，参数的类型或个数不同
方法名称、参数类型、返回值类型全部相同权限对权限没有要求覆写的方法不能拥有更严格的权限范围发生在一个类中发生在继承类中

思考问题问题1：在子类对象实例化时，为什么先调用父类的构造方法呢？
问题2：出现方法覆写的情况时，调用的是子类中覆写的方法。如果现在非要调用父类中的被子类覆写的方法，该咋办？

5.3 super关键字 super：表示”超”的意思。
范例SuperDemo01.java 观察子类对象实例化过程。

String name ; int age ; public Person(){ System.out.println("父类的构造方法") ; } } class Student extends Person{ // 定义Student类 String school ; public Student(){ super(); System.out.println("子类的构造方法") ; public class SuperDemo01{ public static void main(String args[]){ Student stu = new Student(); // 实例化子类对象

5.3 super关键字 super(参数)调用父类带参的构造方法要注意 ①super(参数)语句放在构造方法的首行。
②括号中的参数由父类的构造方法决定。范例SuperDemo02.java 操作答问题2 ：在子类中，非要调用父类的被覆写过的方法，可以通过super.方法(参数)的形式访问父类中的相关方法。范例SuperDemo03.java 调用父类中被子类覆写过的方法

class Person{ // 定义父类，内存分析
String name; void print(){ // 默认的访问权限 System.out.println("Person --> void print()。") ; } } class Student extends Person{ // 定义继承关系 String school; public void print(){ System.out.println("Student --> void print()。") ;} public class SuperDemo03{ public static void main(String args[]){ Student stu = new Student(); stu.print() ; super.print() ; // 访问父类中被子类覆写过的方法

this与super的区别区别 this super 访问属性访问本类中的属性，如果本类中没有此属性，则从父类中继续查找
直接访问父类中的属性方法访问本类中的方法，如果本类中没有此方法，则从父类中继续查找直接访问父类中的方法调用构造调用本类构造，必须放在构造方法的首行调用父类构造，必须放在子类构造方法的首行特殊表示当前对象无此概念内存指向自己指向当前对象的父类

5.4 final关键字 final：在Java中表示“最终”的意思。使用final可以声明类，属性，方法。注意：

范例FinalDemo01.java final class A{ // 使用final定义类 } class B extends A{

范例FinalDemo02.java class A{ // 使用final声明的方法不能被覆写
public final void print(){ System.out.println("HELLO") ; } class B extends A{ public void print(){ System.out.println("WORLD") ;

范例FinalDemo03.java class A{
private final String INFO = "INFO" ;// 声明常量 public void print(){ INFO = "HELLO" ; }

全局常量使用public、static和final联合声明的变量称为全局常量。
public static final String INFO=“ly”; 全局常量是所有对象共同拥有的。

5.5 抽象类 1.abstract：”抽象的”；修饰方法、类。 2.抽象方法： ①定义：只有方法的声明，而没有方法的实现。
③例子： public abstract void print(); 方法声明方法体 public void print() { System.out.println("姓名：" + name + "；年龄：" + age) ; }

5.5 抽象类 3.抽象类 ①定义：包含抽象方法的类就是抽象类。 ②抽象类必须使用abstract关键字来修饰。 ③格式
abstract class 抽象类名称｛　　属性；　　普通方法；　　抽象方法；｝

范例AbstractDemo01.java 结论：抽象类比普通类多了一些抽象方法，其他地方基本都一样。
abstract class A{ //定义一个抽象类 public static final String FLAG = "CHINA" ;// 全局常量 private String name = "张三" ; // 普通属性 public void speak(){ // 普通方法 System.out.println(this.name); } public abstract void print() ; // 定义抽象方法结论：抽象类比普通类多了一些抽象方法，其他地方基本都一样。

5.5 抽象类 4.抽象类使用规则 ⑴抽象类不能直接被实例化。 ⑵如果一个子类继承了一个抽象类，那么这个子类必须实现抽象类中的所有抽象方法。
范例AbstractDemo02.java 继承抽象类 ⑶如果一个子类没有全部实现抽象类的抽象方法。仅实现了部分抽象方法，那么这个子类也要声明为抽象类。 5.思考：一个抽象类可以使用final关键字声明吗？ AbstractDemo03.java

范例：AbstractDemo03.java 实例化抽象类对象
abstract class A{ //定义一个抽象类 public static final String FLAG = "CHINA" ;// 全局常量 private String name = "张三" ; public void speak(){ System.out.println(this.name); } public abstract void print() ; // 定义抽象方法 public class AbstractDemo03{ public static void main(String[] args){ new A();

abstract class A { // 定义一个抽象类
String name ; public A (String name){ this.name = name ; } public abstract void print() ; // 定义抽象方法 } class B extends A { String school ; public B ( String name , String school ) { super(name); this.school = school; } public void print() { System.out.println(this.name + this.school) ; public class AbstractDemo02{ public static void main(String args[]){ new B("张三 "," 沈阳理工大学").print() ;

5.6 接口 1.接口含义 ①广义接口、狭义接口 ②接口：由全局常量和公共的抽象方法组成。从本质上讲，接口是一种特殊的抽象类。
2.接口定义格式 interface 接口名称 { 　　　　　全局常量；　　　　　抽象方法； }

范例InterfaceDemo01.java 接口的定义
Interface A{ // 定义接口A public static final String AUTHOR = "张三" ; // 全局常量 public abstract void print() ; // 抽象方法 public abstract String getInfo() ; // 抽象方法 } 3.简化接口定义操作：范例InterfaceDemo02.java 　 interface A{ // 定义接口A String AUTHOR = "张三" ; // 全局常量 void print() ; // 抽象方法 String getInfo() ; // 抽象方法 } //编译操作

4.实现接口说明：①接口和抽象类一样，也要通过子类实现它，覆写它的全部抽象方法。 ②一个子类可以同时实现多个接口，摆脱了类的单继承的局限。 class 子类 implements 接口A,接口B,…{ 子类语句体； } 范例InterfaceDemo03.java 实现接口

Interface A{ // 定义接口A String AUTHOR = "张三" ; // 全局常量 void print() ; // 抽象方法 String getInfo() ; // 抽象方法 } interface B{ // 定义接口B public void say() ; // 抽象方法 class X implements A,B{ // X类同时实现A和B两个接口 public void say() { System.out.println("Hello World!") ; } public String getInfo(){ return "HELLO" ; } public void print(){System.out.println("作者" + AUTHOR) ; } public class InterfaceDemo03{ public static void main(String args[]){ X x = new X() ; // 实例化子类对象 x.say() ; x.print() ; } } //分析程序、观察结果

5.接口和类的关系类继承类——单继承类实现接口——实现多个接口接口继承接口——多继承 public class A extends B
public class A implements B,C public class A extends D implements B,C public abstract class A implements B,C public abstract class A extends D implements B,C 接口继承接口——多继承 public interface A extends B public interface A extends B,C

4.6 对象的多态性 1.Java中的数据类型 ⑴基本数据类型：其中7种类型可以互相转换转换分为自动转换和强制转换
⑵引用数据类型：对象之间也存在转换转换分为对象向上转型和对象向下转型 2.面向对象三大特征 ⑴封装性 ⑵继承性 ⑶多态性①方法的多态性（重载与覆写） ②对象的多态性：对象转型

4.6 对象的多态性 3.引用类型转换的前提具有继承关系的对象，才能互相转换。 4.对象的向上转型 ①含义：把子类对象转换为父类对象。
②自动完成：继承存在关系——子类是父类的一种.

class Animal { public String name ; Animal ( String name ){ this.name = name ; } } class Dog extends Animal { public String furColor ; Dog ( String name, String furColor ){ super(name); this.furColor = furColor ; } public class PolDemo01{ public static void main(String[] args){ Animal a = new Animal("name"); Dog d = new Dog("bigyellow", "yellow"); a = d ; //赋值时，发生类型转换 System.out.println(a.name); System.out.println(a.furColor); }} //读程序，分析内存 Animal a = new Dog("bigyellow", "yellow");

4.6 对象的多态性 5.对象的向下转型 ①含义：把父类对象转换为子类对象。 ②提问：父类对象是否属于子类对象？ ③强制转换
④规则：只有曾经向上转型过的对象才可以进行向下转型。

class Animal { public String name ; Animal ( String name ){ this.name = name ; } } class Dog extends Animal { public String furColor ; Dog ( String name, String furColor ){ super(name); this.furColor = furColor ; } public class PolDemo02{ public static void main(String[] args){ Animal a = new Dog("bigyellow","yellow"); Dog d = (Dog)a; System.out.println(d.name); System.out.println(d.furColor); } //读程序，分析内存

class Animal { public String name ; Animal ( String name ){ this.name = name ; } } class Dog extends Animal { public String furColor ; Dog ( String name, String furColor ){ super(name); this.furColor = furColor ; } public class PolDemo03{ public static void main(String[] args){ Animal a = new Animal("name"); Dog d = (Dog)a; System.out.println(d.name); System.out.println(d.furColor); } //读程序，分析内存，操作程序

5.8 instanceof 关键字作用：判断一个对象到底是哪个类的实例。格式：对象 instanceof 类
→返回boolean类型的值范例InstanceofDemo.java 验证instanceof关键字的作用

5.8 instanceof 关键字 A a1 = new A() ; B b = new B() ; A a2 = new B() ; 结论：通过子类实例化的对象b同时是子类和父类的实例，所以可以直接进行向上或向下转型；如果直接使用父类实例化本类的对象，则一定不是子类的实例，不能转型。

5.9 抽象类与接口的应用在编程或开发中，要牢记的最重要一点是——一个类永远不要去继承一个已经实现好的类，而只能继承抽象类或实现接口。
1. 为抽象类与接口实例化 2. 抽象类的实际应用——模板设计 3. 接口的实际应用——制定标准 4. 抽象类与接口之间的关系

1. 为抽象类与接口实例化回顾：抽象类和接口中都包含抽象方法，抽象方法是没有方法体的方法，无法实现某一具体的功能，所以抽象类和接口不能直接实例化对象。需要有子类继承，子类必须覆写父类中的全部抽象方法。如今：学了对象的多态性后，可以通过子类的向上转型为抽象类与接口间接实例化对象。这样在使用抽象类与接口时，就可调用本子类中所覆写过的方法。

范例AbstractCaseDemo01.java 为抽象类实例化
abstract class A{ // 定义抽象类A public abstract void print() ;// 定义抽象方法print() } class B extends A { // 定义子类，继承抽象类 public void print(){ // 覆写抽象方法 System.out.println("Hello World!!!") ; public class AbstractCaseDemo01{ public static void main(String args[]){ A a = new B() ; // 通过子类为抽象类实例化 a.print() ;

范例InterfaceCaseDemo01.java 为接口实例化
interface A{ // 定义抽象类A void print() ; // 定义抽象方法print() } class B implements A { // 定义子类，继承抽象类 public void print(){ // 覆写抽象方法 System.out.println("Hello World!!!") ; public class InterfaceCaseDemo01{ public static void main(String args[]){ A a = new B() ; // 通过子类为抽象类实例化 a.print() ;

2. 抽象类的实际应用——模板设计现实生活中的模板违纪卡姓名班级日期事由违纪卡姓名张三班级计算机1班日期
事由上课迟到

2. 抽象类的实际应用——模板设计场景:假设人可以分为学生和工人，学生和工人都可以说话。
分析:说话是一个功能，应该是具体的功能，而说话内容就要由学生或工人自己决定了。父类——抽象类子类

2. 抽象类的实际应用——模板设计范例AbstractCaseDemo02.java 使用抽象类定义模板

3. 接口的实际应用——制定标准现实生活中的标准
U盘、打印机、mp3、数码相机等设备，只要是具有usb接口标准，就都可以插在计算机的usb接口上使用。场景: 若U盘和打印机均实现usb接口，则都可以插在计算机上使用。

3. 接口的实际应用——制定标准范例InterfaceCaseDemo02.java 使用接口制定标准。

4. 抽象类与接口之间的关系区别抽象类接口定义包含抽象方法的类抽象方法和全局常量的集合组成
构造方法、抽象方法、普通方法、常量、变量全局常量、抽象方法使用子类继承抽象类(extends) 子类实现接口(implements) 关系抽象类可以实现多个接口接口不能继承抽象类，但可以继承多个接口对象都通过对象的多态性产生实例化对象（向上转型）局限抽象类有单继承局限接口没有此局限实际作为一个模板作为一个标准选择如果抽象类和接口都可以使用的话，优先使用接口，因为可以避免单继承的局限。

5.10 Object类在Java中，所有的类都是以继承关系存在的。
如果没用extends显式地指出继承哪个类，那么这个类的父类就是Object类。 Object类是Java中最顶层的父类，所有的其他类(包括类库和我们自己编写的类)都是它的子类或间接子类。Java中唯一一个没有父类的类就是Object类。 class Person { } class Person extends Object{ }

5.10 Object类 Java中任何一个类都继承了定义在Object类内的方法。任何子类均可以直接使用这些方法，而且这些方法开发者会经常用到。查阅API文档，了解Object类。方法名称类型作用 public Object() 构造构造方法 public String toString() 普通打印对象时调用 public boolean equals(Object obj) 对象比较

验证toString()方法 class Demo{ // 定义Demo类，实际上就是继承了Object类 }
public class ObjectDemo01{ public static void main(String args[]){ Demo d = new Demo() ; // 实例化Demo对象 System.out.println("不加toString()输出："+d) ; System.out.println("加上toString()输出："+d.toString()) ;

toString()方法的应用结论：由ObjectDemo01.java程序可知，加与不加toString()最终的输出结果是一样的，就是说对象输出时一定会调用Object类中的toString()方法来打印信息。应用：可以根据需要在子类中覆写Object类中的toString()方法,返回需要的信息。范例ObjectDemo02.java 覆写toString()方法取得对象内容。

class Person{ private String name ; // 定义name属性 private int age ; // 定义age属性 public Person(String name,int age){ this.name = name ; this.age = age ; } public String toString(){ //方法覆写 return "姓名" + this.name + "；年龄" + this.age ; public class ObjectDemo02{ public static void main(String args[]){ Person per = new Person("张三", 30) ; System.out.println("对象信息：" + per) ;

equals()方法功能:实现两个对象的比较操作。如果一个类需要实现对象的比较操作，直接在类中覆写equals()方法即可。
范例ObjectDemo03.java 对象的比较操作。

System.out.println(per1.equals(per2)?"是同一个人！" : "不是同一个人！") ;
public boolean equals( Object obj ){ if( this == obj ){ // 地址相等 return true ; // 肯定是同一个对象 } if(!(obj instanceof Person)){ // 不是Person对象，就不用比较 return false ; Person per = (Person) obj ; // 向下转型 if(per.name.equals(this.name)&&per.age == this.age){ return true ; // 依次比较内容 }else{

总结： 1.在任何类里，想进行对象比较，通常是覆写Object类的equals()方法。 2.先进行地址判断，再进行内容比较。 3. public boolean equals( Object obj) Object类里的equals()方法的参数是Object类型的对象，所以此方法可以接收任何类的对象，进行向上转型。 4.当进行内容比较时，必须将Object类型的对象向下转型。并且对象向下转型前，先判断传进来的对象是否是Person的实例。

5.11 包装类 Java设计中的一个主要思想——一切皆对象。问题1：八种基本数据类型能叫作对象吗?
问题2：如果将基本数据类型当对象用，咋办解决方案：将基本数据类型进行包装，形成包装类。例如：从键盘输入的数据系统会默认为是String类型，如果这些数据在程序中要进行数学运算的话，就必须要转换为基本数据类型。这样的功能需要包装类来完成。

1.包装类与基本数据类型的关系序号基本数据类型包装类 1 int Integer 2 char Character 3 short
4 long Long 5 float Float 6 double Double 7 boolean Boolean 8 byte Byte

2. 装箱与拆箱装箱操作：将一个基本类型数据变为包装类拆箱操作：将一个包装类变为基本数据类型 JDK5.0之后提供的自动装箱及拆箱操作。
public class WrapperDemo01{ public static void main(String args[]){ Integer i = 30 ; // 自动装箱成Integer Float f = 30.3f ; // 自动装箱成Float int x = i ; // 自动拆箱为int float y = f ; // 自动拆箱为float }

3. 包装类应用包装类在实际应用中用的最多的操作——将数字字符串变为指定的数据类型。 Integer类（字符串转int型）
public static int parseInt(String s) 2. Float类（字符串转float型） public static float parseFloat(String s) 注意：操作时字符串必须由数字组成。范例WrapperDemo02.java

范例WrapperDemo02.java public class WrapperDemo02{ //查API文档，操作程序
public static void main(String args[]){ String str1 = args[0]; String str2 = args[1]; int x = Integer.parseInt(str1) ; // 将字符串变为int型 float f = Float.parseFloat(str2) ; // 将字符串变为float型 System.out.println( "整数乘方：" + x + " * "+ x + " = " + (x * x) ) ; System.out.println( "小数乘方：" + f + " * " + f + " = " + (f * f) ) ; }

范例WrapperDemo03.java public class WrapperDemo03{
public static void main(String args[]){ String str1 = args[0]; String str2 = args[1]; int x = str1 ; float f = str2 ; System.out.println("整数乘方：" + x + " * " + x + " = " + (x * x)) ; System.out.println("小数乘方：" + f + " * " + f + " = " + (f * f)) ; }

5.12 匿名内部类内部类是在一个类的内部还有另外一个类。匿名内部类：如果一个内部类在整个操作中只使用一次，就可以将其定义成匿名内部类
匿名内部类是在抽象类及接口的基础上发展起来的。范例NoInnerClassDemo01.java

interface A{ // 定义接口A public void printInfo() ; } class B implements A{ // 定义子类实现接口 public void printInfo(){ System.out.println("Hello World!!!") ; } class X { // 定义X类——操作类 public void fun1(){ this.fun2( new B() ) ; // 传递子类实例 public void fun2( A a ){ // 使用接口实例接收 a.printInfo() ; // 调用接口方法 public class NoInnerClassDemo01{ //测试类 public static void main(String args[]){ new X().fun1() ; }}

interface A{ // 定义接口A public void printInfo() ; } class X { // 定义X类——操作类 public void fun1(){ // 定义fun1()方法 this.fun2(new A() { // 匿名内部类 public void printInfo(){ //实现接口中的抽象方法 System.out.println("Hello World!!!") ; } } ) ; } public void fun2(A a){ // 使用接口实例接收 a.printInfo() ; // 调用接口方法 }} public class NoInnerClassDemo02{ public static void main(String args[]){ new X().fun1() ;

解释直接实例化接口对象—— new A(){ };
接口对象是不能直接实例化的，所以在接口实例化后要有一个大括号，在其中编写具体的实现方法。实现抽象方法在实际的开发框架中常见。 new A(){ // 匿名内部类 public void printInfo(){ //实现接口中的抽象方法 System.out.println("Hello World!!!") ; }

5.13 StringBuffer类 buffer：缓冲区。
String类与StringBuffer类的区别 String s1 = “Hello”; String s2 = “World”; s1 = s1 + s2;

public class StringBufferDemo{
public static void main(String[] args){ String s = "Mircosoft"; char[] a = {'a' , 'b' , 'c'}; StringBuffer sb1 = new StringBuffer(s); sb1.append('/').append("IBM").append('/'); System.out.println(sb1); StringBuffer sb2 = new StringBuffer("数字"); for (int i = 0 ;i <= 9; i ++){ sb2.append(i); } System.out.println(sb2); sb2.delete(8,sb2.length()).insert(0,a); System.out.println( sb2.reverse() ); }

5.14 本章小结 1.继承可以扩充已有类的功能。通过extends关键字实现，可将父类的成员（包含属性与方法）继承到子类。 2.Java在执行子类的构造方法前会先调用父类中无参的构造方法，其目的是为了对继承自父类的成员做初始化操作。 3.父类有多个构造方法时，可在子类的构造方法中通过super(参数)的形式来调用父类特定的构造方法。 4.this(参数)用于在同一类内调用其他的构造方法，而super(参数)则用于从子类的构造方法中调用父类的构造方法。

5.使用this调用属性或方法时会先从本类中查找。如果本类中没有查找到，再从父类中查找；而使用super则会直接从父类中查找需要的属性或方法。 6.重载是指在相同类内定义名称相同但参数个数或类型不同的方法，因此，Java可依据参数的个数或类型调用相应的方法。 7.覆写是在子类当中定义名称、参数个数与类型均与父类相同的方法，用以覆写父类的方法 8.如果父类的方法不希望被子类覆写，可在父类的方法前加上final关键字，这样该方法就不会被覆写了。

9.final的一个功能是把它放到数据成员变量前面，可定义一个常量，此常量的内容不可再修改。使用public、static、final可以声明全局常量。 10.所有的类均继承Object类。一个好的类应该覆写Object类中的toString()、equlas()方法，所有的对象都可以向Object类进行向上转型。 11.Java可以创建抽象类，专门用来当做父类。抽象类的作用类似于“模板”，其目的是依据其格式来修改并创建新的类。 12.抽象类中的方法分为两种，一种是普通方法，另一种是以abstract关键字开头的抽象方法。抽象方法没有定义方法体，而是要保留给抽象类派生出的新类来定义。

13. 抽象类不能直接产生对象，必须通过对象的多态性进行实例化操作。 14
13.抽象类不能直接产生对象，必须通过对象的多态性进行实例化操作。 14.接口是方法和全局常量的集合。接口必须被子类实现，一个接口可以同时继承多个接口，一个子类可以同时实现多个接口。 15.Java不允许类的多重继承，但是允许实现多个接口。 16.Java对象的多态性分为向上转型和向下转型。 17.通过instanceof关键字判断对象属于哪个类。 18.匿名内部类的作用是可以利用内部类创建不具有名称的对象，并利用它访问类中的成员。

Similar presentations

Similar presentations

About project

反馈

请登录

Auth with social network:

Similar presentations

Similar presentations

About project

反馈