JAVA程序设计实用教程04类的封装性继承性多态性与接口.ppt

1、第四章 类的封装性、继承性、多态性与接口前言本章的目的：类的三大特性(封装性、继承性、多态性)、extends、super、方法重载与覆盖、接口(interface)、抽象类(abstract)、特殊的类(实名内部类、匿名内部类、泛型类、Class类)回顾关键词：类、对象、对象生成(new)、对象清除、对象的内存分配、构造方法、main方法、this、static、final、import小题目1、 下列程序有没有错误？class CMethod int i; int j; static int s; public void add() s=i+j; static void add(int i

2、, int j) this.i=i; this.j=j; s=i+j; 小节安排类的封装性、继承性、多态性与接口4.1、封装性4.2、继承性4.3、多态性4.4、抽象类4.5、接口4.6、内部类4.1 封装性目的限制在类的外部对类内部成员进行访问，只通过公共接口来访问类的成员数据。屏蔽细节：这是程序设计的基本思想方法，便于程序功能的扩展和程序的维护。封装类大多数变量都是私有的，变量通过他们自己类的方法修改,其它类都只与一个类中很少的几部分接口；若变量或方法为公有，它就是接口的一部分，其它类可以访问它；若为私有，它是实现的一部分，只有类自己的成员可以访问它访问权限的设置权限同一类同一包不同包的子

3、类所有类public允许允许允许允许protected允许允许允许不允许默认允许允许不允许不允许private允许不允许不允许不允许类的访问权限的设置类的权限有两种：默认和public。如果在一个源程序文件中，声明了若干个类的话，只能有一个类的权限关键字是public。这个类的名字应该和程序文件同名，main方法也应该在这个类中，否则程序无法执行。类的成员的访问权限设置用权限关键字设置类的成员的权限，以此决定是否允许其类外部的代码访问这些成员。例： private int name,sex,age,stuID; public void setName(String name);访问控制方式：p

4、ublic被修饰为public的类是公共类，它可供所在包的其他类使用，也可供其他包中的类使用，在程序中可以用import语句引入其他包中的public类。被public定义的类中成员变量或方法可以供其他类访问，表明对外开放的方式；一般类的定义中，含有少量(或者没有) public 变量，部分 public 方法。访问控制方式：private设置private访问权限，则该类的成员只能被同一类中的成员访问，而不让其他类进行访问。目的: 隐藏具体的实现细节变量常常是private 采用 public “get” 方法读取数据采用 public “set”方法写数据访问控制方式：protected同

5、一个包内的所有类的所有方法都能访问该成员如果不在同一个包内的类的方法要访问该成员，则该类必须是该成员所在的类的子类访问控制方式： 默认 (缺省方式)默认的权限，该类的成员能被同一包中的类访问。封装性的可以带来的优点基本思想: 提供对外的通讯方式，封装内部的实现机制增加内部实现部分的可替换性减小类之间的耦合关系，方便模块划分容易保证类内部数据间的一致性，从而提高软件的可靠性何时为public或private?基本思想类常常是public成员变量常常是private. 构造方法一般是public. 方法“get”与“set”是 public. 其它方法需要根据实际的需要而定上面的思想可以用于大部分

6、的程序设计(也许90%)例子：根据以下的设计要求编写java源代码。类名: Student变量(访问权限均为private):name(String) /姓名age(int) /年龄方法:构造方法(没有参数,设置姓名为“无名氏”，年龄为20)setName(有一个名为name的String型参数,将name的值设为这个新值),getName (没有参数,返回姓名)setAge(有一个名为age的int型参数,将age的值设为这个新值),getAge (没有参数,返回年龄)isSameAge(有一个参数s,是另一个Student对象的引用,如果两个Student对象的age相同,则返回true,

7、否则返回false)public class Studentprivate String name;private int age;public Student()name=无名氏;age=20;public void setName(String name)=name;public String getName()return name;public void setAge(int age)this.age=age;public int getAge()return age;public boolean isSameAge(Student s)if(s.age-this.a

8、ge=0) return true;return false;public static void main(String args)Student s1=new Student();Student s2=new Student();s2.age=20;System.out.println(s1.isSameAge(s2);Student类（续）某Java源程序中有一个类的定义为:public class MyPrg，则该源程序的文件名应该为:_ 。小题目MyPrg.java对象是用_关键字实例化类之后的结果，_访问修饰符所声明的类成员，仅能被同包(同路径)或具有继承关系的相关类使用。newp

9、rotected阅读下列程序，输出结果是( )public class Example String str=new String(hello); char ch=d,b,c; public static void main(String args) Example ex=new Example(); ex.change(ex.str,ex.ch); System.out.println(ex.str+and+ex.ch0); public void change(String str,char ch) str=world; ch0= a; A. hello and d B. hello an

10、d a C. world and d D. world and a 小题目BTest.java程序代码如下,以上程序编译后用如下命令运行： java Test 1 2 3 4 运行的输出结果是什么？（ ） public class Test public static void main(String args) System.out.println(args2); A. 1 B. 2 C. 3 D. 4 小题目C小节安排类的封装性、继承性、多态性与接口4.1、封装性4.2、继承性4.3、多态性4.4、抽象类4.5、接口4.6、内部类4.2、继承性继承是复用程序代码的有力手段，当多个类(Sub

11、1，Sub2)之间存在相同的属性和方法时，可从这些类抽象出父类SuperClass。被继承的类称为超类（父类）。从超类派生出来（继承超类）的新类称子类。Java只支持单重继承，不支持多重继承继承的层次结构一个子类成为另一个子类的超类。人学生行政人员教师本科生研究生继承的基本语法 class extends 子类体 例：public class SubClass extends SuperClass Student和Teacher继承People25例：Student和Teacher继承Peoplepublic class People String name;char sex;int age;

12、public String getName()return name;public char getSex()return sex;public int getAge()return age;public void printInfo()System.out.println(“name:”+name+“ sex:”+sex+“ age:”+age);例：Student和Teacher继承Peoplepublic class Student extends PeopleString studentID;String major;public String getMajor()return maj

13、or;public String getStudentID()return studentID;例：Student和Teacher继承Peoplepublic class Teacher extends PeopleString teacherID;String department;public String getDepartment()return department;public String getTeacherID()return teacherID;子类继承超类的成员变量继承原则：子类只继承超类中非private的成员变量隐藏原则：子类的成员变量和超类的成员变量同名时，超类的成

14、员变量被隐藏（不能继承）子类继承超类的成员方法继承原则：子类只继承超类中非private的成员方法。覆盖原则：子类的成员方法和超类的成员方法同名时，超类的成员方法被子类的成员方法覆盖（不能继承）。super关键字super表示对某个类的超类的引用。如子类和超类有同名的成员变量或方法，则：super.super.表示引用超类的成员（如无super则表示子类中的同名成员）this关键字在类定义中的方法中需要引用正在使用该方法的对象时，可以用“this”表示。用this引用的使用方法如下：用this指代对象本身访问本类的成员： this. this.调用本类的构造方法： this(参数列表)构造方法

15、的继承构造方法不存在继承关系。如果子类没有构造方法，则它默认调用超类无参数的构造方法；如果子类有构造方法，那么在创建子类的对象时，则将先执行超类的构造方法，然后再执行自己的构造方法。对于超类中包含有参数的构造方法，子类可以通过在自己的构造方法中使用super关键字来引用，而且必须是子类构造方法中的第一条语句。用super调用超类的构造方法：super(参数列表)例：通过super关键字实现对父类构造方法与成员方法的访问class People private String name ;private char sex;private int age;public People(String n

16、ame,char sex,int age) = name;this.sex=sex;this.age = age;public String getDetails( )return Name:+name+nsex:+sex+nage: +age;例：通过super关键字实现对父类构造方法与成员方法的访问class Student extends People private String studentID;private String major;public Student(String name,char sex,int age,String stuID,String

17、major)super(name,sex,age);this.studentID=stuID;this.major=major;public String getDetails( )return super.getDetails( )+nStudentID:+ studentID+nMajor:+major;public class TestSuperpublic static void main(String srgs)Student s = new Student(TOM,男,20,20070308017,Computer);System.out.println(s.getDetails(

18、);子类对象的创建与实例化过程1、分配对象所需的全部内存空间，并初始化为“0”值2、按继承关系，自顶向下显式初始化3、按继承关系，从顶向下调用构造方法注意：一般子类构造方法的第1行通过super来调用父类的构造方法，若不使用super关键字指定，则自动调用父类的无参数构造方法。如果父类中没有无参数的构造方法，则将产生错误。子类对象的创建与实例化过程需要注意的是，若子类调用父类的构造方法，在子类的构造方法中省略掉super关键字，则系统默认有“super()”，即调用父类不带参数的构造方法。由于Java语言规定如果一个类中含有一个或多个构造方法，系统不提供默认的构造方法（不含参数的构造方法），所

19、以当在父类中定义了多个构造方法时，应考虑包括一个不带参数的构造方法，以防止子类省略super关键字时出现错误。class Member int instanceVar; Member(int i) instanceVar=i; class SubMember extends MemberSubMember(int j) instanceVar=j; public class ExtendsTest public static void main(String args) Member m1 = new Member(); Member m2 = new Member(); SubMember

20、m3=new SubMember(3);class Member int instanceVar; Member(int i) instanceVar=i; class SubMember extends MemberSubMember(int j) instanceVar=j; public class ExtendsTest public static void main(String args) Member m1 = new Member(1); Member m2 = new Member(2); SubMember m3=new SubMember(3);class Member

21、int instanceVar; Member(int i) instanceVar=i; class SubMember extends MemberSubMember(int j) super(j); instanceVar=j; public class ExtendsTest public static void main(String args) Member m1 = new Member(1); Member m2 = new Member(2); SubMember m3=new SubMember(3);正确！class Member int instanceVar; Mem

22、ber(int i) instanceVar=i; Member() class SubMember extends MemberSubMember(int j) super(j); instanceVar=j; public class ExtendsTest public static void main(String args) Member m1 = new Member(1); Member m2 = new Member(2); SubMember m3=new SubMember(3);正确！class Member int instanceVar; Member(int i)

23、instanceVar=i; Member() class SubMember extends MemberSubMember(int j) instanceVar=j; public class ExtendsTest public static void main(String args) Member m1 = new Member(); Member m2 = new Member(); SubMember m3=new SubMember(3);正确！class Member int instanceVar; Member(int i) instanceVar=i; Member()

24、 class SubMember extends MemberSubMember(int j) Super(j); instanceVar=j; public class ExtendsTest public static void main(String args) Member m1 = new Member(); Member m2 = new Member(); SubMember m3=new SubMember(3);正确！练习：阅读下面的程序，经编译后，运行结果是什么class Super public int i=0; public Super() i=1; public cl

25、ass Sub extends Super public Sub() i=2; public static void main(String args) Sub s=new Sub(); System.out.println(s.i); 练习：阅读下面的程序，经编译后，运行结果是什么class Super public int i=0; public Super() i=1; public class Sub extends Super public Sub() i=2; public static void main(String args) Sub s=new Sub(); System.

26、out.println(s.i); 运行结果：2练习：阅读下面的程序，经编译后，运行结果是什么class Person public Person() System.out.println(hi!); public Person(String s) this(); System.out.println(I am +s); public class Who extends Person public Who() this(I am Tony); public Who(String s) super(s); System.out.println(How do you do?); public st

27、atic void main(String args) Who w = new Who(Tom); Hi!I am TomHow do you do?练习：阅读下面的程序，经编译后，运行结果是什么class Person public Person() System.out.println(hi!); public Person(String s) this(); System.out.println(I am +s); public class Who extends Person public Who() this(I am Tony); public Who(String s) supe

28、r(s); System.out.println(How do you do?); public static void main(String args) Who w = new Who(); Hi!I am I am TonyHow do you do?继承关系中对成员的访问（最近匹配原则） （1）在子类中访问属性和方法时将优先查找自己定义的属性和方法。如果该成员在本类存在，则使用本类的，否则，按照继承层次的顺序到其祖先类查找。（2）this关键字特指本类的对象引用，使用this访问成员则首先在本类中查找，如果没有，则到父类逐层向上找。（3）super特指访问父类的成员，使用super首先

29、到直接父类查找匹配成员，如果未找到，再逐层向上到祖先类查找终止继承出于安全性方面的考虑，要避免子类继承超类的某个方法，可以使用“final”关键字来使继承终止。 这样使此方法不会在子类中被覆盖（即子类中不能有和此方法同名的方法）不能被继承的类称为最终类。 如：final class Last; 用final说明的成员方法为最终方法。 如：public final void printsuper( )测试类的继承关系在java中，类一次只能继承一个超类使用“是一个（is a）短语验证继承”例如：Person和Student继承是正确的，因为一个Student是一个Person，即Studen i

30、s a Person注：类只有用public、final或缺省定义，如果用final定义的类则不能被继承。小节安排类的封装性、继承性、多态性与接口4.1、封装性4.2、继承性4.3、多态性4.4、抽象类4.5、接口4.6、内部类4.3 多态性多态性是指同一个名字的若干个方法，有不同的实现（即方法体中的代码不一样）。多态的两种表现形式：（1） 同一类中的方法多态，称为方法重载overloading(静态多态性)：同一类中允许多个同名方法，区分要点：参数的个数不同，或者是参数类型不同，或者是参数的顺序不同（2） 子类对父类方法的重新定义，称为方法覆盖overriding (动态多态性) ：方法名、

31、返回值和参数形态完全一样。Java标准输出方法的重载例：下面程序中第4行调用哪一行的show方法？public class Test public static void main(String argv) Test t = new Test(); t.show(1+3); public void show(int Val1,int Val2) System.out.println(Val1+Val2); public void show(int Val1) System.out.println(Val1); public void show(int Val1,int Val2,int Val

32、3) System.out.println(Val1+Val2+Val3); public class Test public static void main(String argv) Test t = new Test(); t.show(1+3); public void show(int Val1,int Val2) System.out.println(Val1+Val2); public void show(int Val1) System.out.println(Val1); public void show(int Val1,int Val2,int Val3) System.

33、out.println(Val1+Val2+Val3); 例：下面程序中第4行调用哪一行的show方法？方法重载的原则方法名相同。方法的参数类型、个数、顺序只要有一项不相同。返回类型、修饰符可相同或不相同。 public int area(int r) public float area(int h,float r) public float area(float h,int r) 是正确的方法重载，而下面的则不是正确的方法重载： public int area(float h,float r) public float area(float h,float r)构造方法也能重载小题目下述哪一

34、组方法，是一个类中方法重载的正确写法？ A) int addValue( int a, int b )return a+b; float addValue ( float a, float b) return a+b;B) int addValue (int a, int b )value=a+b; float addValue ( int a, int b) return (float)(a+b);C) int addValue( int a, int b )return a+1; int addValue ( int a, int b) return a+b;D) int addValue

35、( int a, int b ) return a+b; int addValue ( int x, int y ) return x+y;小题目下述哪一组方法，是一个类中方法重载的正确写法？ A) int addValue( int a, int b )return a+b; float addValue ( float a, float b) return a+b;B) int addValue (int a, int b )value=a+b; float addValue ( int a, int b) return (float)(a+b);C) int addValue( int

36、a, int b )return a+1; int addValue ( int a, int b) return a+b;D) int addValue( int a, int b ) return a+b; int addValue ( int x, int y ) return x+y;激活重载的构造方法在一个构造方法中可以利用另一个构造方法。class Peopleprivate String name;private int age;public People(String n, int age)name = n ;this.age = age;public People( Stri

37、ng n) this(n,0); public People( ) this(“Unknown”); 一般地，重载的方法应当具有相似的行为(功能)public class ShapeArea public double area(float r) return Math.PI*r*r; public double area(float a,float b) return a*b; public double area(float a,float b,float c) float d; d=(a+b+c)/2; return Math.sqrt(d*(d-a)*(d-b)*(d-c); publ

38、ic static void main(String args) ShapeArea s=new ShapeArea(); System.out.println(The area of circle : +s.area(3); System.out.println(The area of rectangle : +s.area(7,4); System.out.println(The area of triangle : +s.area(3,4,5); 例：在类ShapeArea中声明三个同名方法area，求圆、矩形和三角形的面积方法的覆盖（重写）在子类和超类中有同名的方法（参数也相同），子类

39、中的方法覆盖超类的方法。如果超类和子类有同名且参数相同的方法，那么超类的对象调用超类的方法，子类的对象调用子类的方法。通过覆盖可以使同名的方法在不同层次的类中有不同的实现注意：子类中重写的方法和父类中被重写的方法要具有相同的名字，相同的参数表和相同的返回类型，只是函数体不同。方法覆盖的原则（1）1、子类方法的名称、参数签名和返回类型必须与其父类的方法的名称、参数签名和返回类型一致public class Basepublic void method().public class Sub extends Basepublic void method(). public int method(in

40、t a) return 0; 方法覆盖的原则（2）2、子类方法不能缩小父类方法的访问权限 public class Base public void method().public class Sub extends Base protected void method()./编译错误，子类方法缩小了父类方法的访问权限方法覆盖的原则（3）3、子类方法不能抛出比父类方法更多的异常4、方法覆盖只存在于子类和父类（包括直接父类和间接父类）之间。在同一个类中方法只能被重载，不能被覆盖。5、父类的静态方法不能被子类覆盖为非静态的方法，反之亦然；6、子类可以定义与父类的静态方法同名的静态方法，以便在子类中

41、隐藏父类的静态方法。7、父类的私有方法不能被覆盖8、父类的抽象方法可以被子类覆盖：子类实现父类的方法或重新声明父类的抽象方法。小题目public class TestDemo int m=5;public void some(int x) m=x; public static void main(String args ) new Demo().some(7);class Demo extends TestDemo int m=8;public void some(int x) super.some(x);System.out.println(m);A5 B8 C7 D无任何输出 E编译错误

42、答案：CSystem.out.println(super.m);答案：B练习：选择题对于下列代码： public class SupperClass public int sum( int a, int b) return a+b; class SubClass extends SupperClass 下述哪个方法可以加入类SubClass? ( ) A) int sum ( int a, int b ) return a+b; B) public void sum (int a, int b ) return ; C) public float sum ( int a, int b) ret

43、urn a+b; D) public int sum ( int a, int b ) return a+b; E) public int sum ( float a, int b ) return a+b;答案：D、E小节安排类的封装性、继承性、多态性与接口4.1、封装性4.2、继承性4.3、多态性4.4、抽象类4.5、接口4.6、内部类4.4 抽象类Abstract关键字：可修饰类和方法，被修饰的类称为抽象类，被修饰的方法称为抽象方法抽象类是专门设计来让子类继承的类。抽象类提供一个类型的部分实现，可以有实例变量，构造方法，抽象方法和具体方法。一个抽象类不会有实例。抽象方法是必须被子类覆盖的

44、方法。如果一个类不具有抽象属性，不能在该类中定义抽象方法。抽象类的作用抽象类是表征我们对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。好比，我们都知道三角形是一个形状，世界上有三角形这样具体的东西，但是确没有形状这样具体的东西，我们要描述这个形状的概念就要用到抽象类。因此在java中抽象类是不允许被实例化的。在面向对象领域，抽象类主要用来进行类型隐藏。那什么是类型隐藏呢？我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。好比，动物

45、是一个抽象类，人、猴子、老虎就是具体实现的派生类，我们就可以用动物类型来隐藏人、猴子和老虎的类型。抽象类的作用抽象类通常代表一个抽象概念，可以用一句话来概括抽象类的用途：抽象类是用来继承的。通过抽象类使开发的系统具有良好的扩展性和可复用性 声明抽象类和方法格式abstract class 成员变量； 方法（） 方法体 ； /定义一般方法 abstract 方法( ); /定义抽象方法 抽象方法不用实现代码，而是在子类中实现所有的抽象方法。对于成员方法，不能同时用static和abstract说明。对于类，不能同时用final和abstract说明。抽象类抽象类也可有普通的成员变量或方法。抽象类

46、可以有构造方法，但不能直接用来生成实例。一般可通过定义子类进行实例化。可以生成抽象类的变量，该变量可以指向具体的一个子类的实例。 abstract class Employee abstract void raiseSalary(int i) ; class Manager extends Employee void raiseSalary(int i ) . Employee e = new Manager( ) ;abstract class Shapeabstract protected double area();abstract protected void draw();class

47、 Rectangle extends Shapefloat width,length;Rectangle(float w,float l)width=w;length=l;public double area() return width*length; public void draw();public class ShapeDemopublic static void main(String args)Rectangle r=new Rectangle(6,12);System.out.println(The area of rectangle:+r.area();例：抽象类的例子必须覆盖

48、父类的abstract方法练习：以下程序的编译和运行结果为？ abstract class Base abstract public void myfunc(); public void another() System.out.println(Another method); public class Abs extends Base public static void main(String args ) Abs a = new Abs(); a.amethod(); public void myfunc() System.out.println(My Func); public voi

49、d amethod() myfunc(); A 输出结果为 My FuncB 编译指示 Base 类中无抽象方法C 编译通过但运行时指示Base 类中无抽象方法D 编译指示Base 类中的myfunc方法无方法体答案：A小节安排类的封装性、继承性、多态性与接口4.1、封装性4.2、继承性4.3、多态性4.4、抽象类4.5、接口4.6、内部类4.5 接口接口是在程序开发的早期建立一组协议（规范公共的操作接口）而不具体实现，便于设计更合理的类层次，代码更灵活在Java中，一个类只能有一个超类。但Java提供了接口用于实现多重继承，一个类可以有一个超类和多个接口。接口(interface)是一个特殊

50、的类：由常量和抽象方法组成。 接口的定义public interface 接口名 extends 父接口名列表 /常量声明 常量的数据类型 常量标识符 = 常量值 ; /抽象方法声明 返回类型 方法名(参数列表) throw 异常列表； 接口只包括常量定义和抽象方法。接口具有继承性,一个接口还可以继承多个父接口，父接口间用逗号分隔。 系统默认,接口中所有属性的修饰都是 public static final，也就是静态常量。 系统默认,接口中所有方法的修饰都是 public abstract。接口定义的形式1接口中声明的变量全部为final和static类型的，并且这个接口的作用在于定义一些值

51、不能改变的变量。举个例子：publicinterfaceObjectConstants publicstaticfinalStringSPACE=newString(); publicstaticfinalcharFORMAT=t;接口定义的形式2接口中只定义可供实现的抽象方法 publicinterfaceFlyer publicvoidtakeoff(); publicvoidland(); publicvoidfly();接口定义的形式3接口中既声明变量，又定义可供实现的抽象方法。如非必要，一般会将这样一个接口定义拆分成两个接口定义接口的实现(implements) 接口定义了一套行为规

52、范，一个类实现这个接口就要遵守接口中定义的规范，实际上就是要实现接口中定义的所有方法。接口实现的格式：class implements 接口名1，接口名2，一个接口可以被一个或多个类实现。当一个类实现了一个接口，它必须实现接口中所有的方法，这些方法都要被说明为public，否则会产生访问权限错误。例:接口的实现用面向对象的思想定义一个接口Area，其中包含一个计算面积的方法CalsulateArea();设计MyCircle和MyRectangle两个类都实现这个接口中的方法CalsulateArea()，分别计算圆和矩形的面积写出测试以上类和方法的程序TestArea.java。注：圆周率：

53、Math.PI interface Areapublic double CalsulateArea();class MyCircle implements Areadouble r;public MyCircle(double r)this.r=r;public double CalsulateArea()return Math.PI*r*r;class MyRectangle implements Areadouble width,height;public MyRectangle(double w,double h)width=w;height=h;public double Calsul

54、ateArea()return width*height;class TestArea public static void main(String args) MyCircle c=new MyCircle(2.0); System.out.println(圆的面积：+c.CalsulateArea(); MyRectangle r=new MyRectangle(2.0,3.0); System.out.println(矩形的面积：+r.CalsulateArea(); 接口和抽象类的区别接口可以多重继承，抽象类不可以抽象类内部可以有实现的方法，接口则没有实现的方法接口与实现它的类不构成类

55、的继承体系，即接口不是类体系的一部分。因此，不相关的类也可以实现相同的接口。而抽象类是属于一个类的继承体系，并且一般位于类体系的顶层。接口的优势：通过实现多个接口实现多重继承，能够抽象出不相关类之间的相似性。创建类体系的基类时，若不定义任何变量并无需给出任何方法的完整定义，则定义为接口；必须使用方法定义或变量时，考虑用抽象类。 小题目下列关于接口和抽象类的说法不正确的是？( ) A) 接口也有构造方法B) 实现接口时，需对接口中的所有方法都要实现C) 抽象类也有构造方法 D) 抽象类可以派生出子类A以下是接口I的定义：interface Ivoid setValue(int val);int

56、getValue();以下哪段代码能通过编译？A、 class A extends I int value; void setValue(int val)value=val; int getValue()return value; B、 class B implements I int value; void setValue(int val)value=val; C、 interface C extends I void increment( ); D、 interface D implements I void increment(); 小题目接口的实现(implements) 接口里面的

57、所有属性都为public static final的，即使你不写出来，也会被默认为这样的，接口里面的方法是且只能是public，就算你在接口里不写，那也是默认的public的，但在用类实现接口的时候，必须将方法写为public的，不能不写，应为不写会被默认为是default的，这样权限就发生变化了，就会出错。小节安排类的封装性、继承性、多态性与接口4.1、封装性4.2、继承性4.3、多态性4.4、抽象类4.5、接口4.6、内部类4.6内部类内部类的类名只用于定义它的类或语句块之内，在外部引用它时必须给出带有外部类名的完整名称，并且内部类的名字不允许与外部包类的名字相同。内部类可以是抽象类或接口

58、，若是接口，则可以由其它内部类实现按照内部类是否含有显示的类名，可将内部类分为：实名内部类匿名内部类1、实名内部类格式：类修饰词表 class 类名 extends 父类名 implements 接口名列表 类体实名内部类的封装性增加了保护模式和私有模式，即实名内部类的修饰词可以是protected或private实名内部类的修饰词可以是static，称为静态实名内部类没有static修饰的内部类，称为不具有静态属性的实名内部类，它的成员域若有静态属性，则必须有final属性，但不能有静态属性的方法创建实名内部类创建静态实名内部类格式： new 外部类名.实名内部类名(构造方法调用参数列表)创

59、建不具有静态属性的实名内部类格式： 外部类表达式.new 实名内部类名(构造方法调用参数列表)创建实名内部类public class J_Outer static class J_Inner1 final static double PI=3.1415; double Area(double r) return PI*r*r; class J_Inner2 final static String FORMAT=“0-90-5”; double Area(double w,double h) return w*h; public static void main(String args) J_O

60、uter.J_Inner1 c1=new J_Outer.J_Inner1();/J_Inner1是static J_Outer o=new J_Outer(); J_Outer.J_Inner2 c2= o. new J_Inner2();/J_Inner2是非static 访问实名内部类成员或方法访问静态实名内部类的静态成员域格式： 外部类名.实名内部类名.静态成员域名或方法 System.out.println(J_Outer.J_Inner1.PI);访问静态实名内部类的不具有静态属性的成员域格式： 表达式.成员域名或方法 J_Outer.J_Inner1 c11=new J_Oute