1.给出如下层次图和程序片段，下列哪个命题是正确的？【选择一项】
Animal
Mammal
Dog Cat Raccoon Elephant
(implements) (implements)
( Washer ) ( Washer )
1. Cat sunflower;
2. Washer wawa;
3. Elephant pogo;
4.
5. sunflower = new Cat();
6. wawa = sunflower;
7. pogo = (Elephant)wawa;
A第6行导致程序编译失败。
B第7行导致程序编译失败。
C编译通过但是第7行会抛出异常。
D D．以上结果均不是。
2.下列那些命题是不正确的？【选择两项】
A JAVA程序通过接口实现多重继承。
B JAVA里面所有的异常、接口或者其他类，都从Object类扩展而来。C构造方法可以用private修饰，并且可以抛出异常。
D装箱类一共有六个。
3.下列哪些命题为假？【选择三项】
A静态方法只能被类调用，不能被实例调用。
B所有数据类型都可以用==判断恒等。
C equals()方法成立的地方，==也一定成立。
D包含抽象方法的类一定是抽象类。
4.试图编译、运行下列程序，结果是什么？【选择一项】
//Foo.java
interface Foo {
int k = 0;
}
//Test.java
public class Test implements Foo {
public static void main(String[] args) {
int i;
Test test = new Test();
i = test.k;
i = Test.k;
i = Foo.k;
}
}
A编译失败。
B编译成功。
C运行异常。
D以上结果均不是。
5.下列修饰符不能用于顶层类的是哪个【选择一项】。
A public
B private
C abstract
D final
6.哪些命题为真？【选择两项】
A在Java中，implement用于实现接口。
B非抽象类的子类可以声明为abstract。
C超类的所有成员都将由子类继承。
D final类不可以是抽象的。
E如果类中的所有成员都声明为private，则该类不能声明为public。
7.哪些关于接口的命题为真？【选择两项】
A接口允许多重实现接口。
B接口可以被任意数目的其他接口扩展。
C接口可以扩展任意数目的其他接口。
D接口的成员变量从来不会是static。
E接口的方法总会被声明为static。
8.给出下面的程序：
1. interface Base {
2. boolean m1 ();
3. byte m2(short s);
4. }
下面哪两段代码将编译通过? 【选择两项】
A interface Base2 implements Base {}
B abstract class Class2 extends Base {
public boolean m1() { return true; }
}
C abstract class Class2 implements Base { }
D abstract class Class2 implements Base {
public boolean m1() { return (7 > 4); } }
E class Class2 implements Base {
boolean m1() { return false; }
byte m2(short s) { return 42; }
}
9.给出下面的代码：
1. interface Animal{
2. void soundOff();
3. }
4.
5. class Elephant implements Animal{
6. public void soundOff(){
7 . System.out.println(“Trumpet”);
8. }
9. }
10.
11. class Lion implements Animal{
12. public void soundOff(){
13. System.out.println(“Roar”);
14. }
15. }
16.
17. class Alphal{
18. static Animal get(String choice){
19. if (choice.equalsIgnoreCase(“meat eater”)){
20. retum new Lion();
21 }else{
22 retum new Elephant();
23 }
24 }
25}
哪条语句能够正确编译? 【选择一项】
A new Animal().soundOff();
B Elephant e =new Alphal();
C Lion l=Alpha.get(“meat eater”);
D new Alphal().get(“veggie”).soundOff();
10.给出下面的程序：【选择一项】
1.class Foo {
2. class Bar{ }
3.}
4.class Test {
5. public static void main (String [] args) {
6. Foo f = new Foo();
7. //
8. }
9.}
哪一条语句插入第7行能创建一个Bar实例?
A Foo.Bar b = new Foo.Bar();
B Foo.Bar b = f.new Bar();
C Bar b = new f.Bar();
D Bar b = f.new Bar();
E Foo.Bar b = new f.Bar();
11.给出下面的代码：
1. public interface Foo {
2. int k = 4;
3. }
哪三条语句等价于第2行语句? 【选择三项】
A final int k = 4;
B public int k = 4;
C static int k = 4;
D abstract int k = 4;
E volatile int k = 4;
F protected int k = 4;
1.给出如下层次图和程序片段，下列哪个命题是正确的？【选择一项】 Animal Mammal Dog Cat Raccoon Elephant (implements) (implements) ( Washer ) ( Washer ) 1. Cat sunflower; 2. Washer wawa; 3. Elephant pogo; 4. 5. sunflower = new Cat(); 6. wawa = sunflower; 7. pogo = (Elephant)wawa; A第6行导致程序编译失败。 B第7行导致程序编译失败。 C编译通过但是第7行会抛出异常。 D D．以上结果均不是。 2.下列那些命题是不正确的？【选择两项】 A JAVA程序通过接口实现多重继承。 B JAVA里面所有的异常、接口或者其他类，都从Object类扩展而来。C构造方法可以用private修饰，并且可以抛出异常。 D装箱类一共有六个。 3.下列哪些命题为假？【选择三项】 A静态方法只能被类调用，不能被实例调用。 B所有数据类型都可以用==判断恒等。 C equals()方法成立的地方，==也一定成立。 D包含抽象方法的类一定是抽象类。 4.试图编译、运行下列程序，结果是什么？【选择一项】 //Foo.java interface Foo { int k = 0; } //Test.java public class Test implements Foo {
public static void main(String[] args) { int i; Test test = new Test(); i = test.k; i = Test.k; i = Foo.k; } } A编译失败。 B编译成功。 C运行异常。 D以上结果均不是。 5.下列修饰符不能用于顶层类的是哪个【选择一项】。 A public B private C abstract D final 6.哪些命题为真？【选择两项】 A在Java中，implement用于实现接口。 B非抽象类的子类可以声明为abstract。 C超类的所有成员都将由子类继承。 D final类不可以是抽象的。 E如果类中的所有成员都声明为private，则该类不能声明为public。 7.哪些关于接口的命题为真？【选择两项】 A接口允许多重实现接口。 B接口可以被任意数目的其他接口扩展。 C接口可以扩展任意数目的其他接口。 D接口的成员变量从来不会是static。 E接口的方法总会被声明为static。 8.给出下面的程序： 1. interface Base { 2. boolean m1 (); 3. byte m2(short s); 4. } 下面哪两段代码将编译通过? 【选择两项】 A interface Base2 implements Base {} B abstract class Class2 extends Base {
内部类练习题 一、按要求填空 1.请在以下代码的基础上完成下面几个小题 （1）在①和②的位置标注出内部类和外部类 （2）在③的位置定义一个count变量用来存放Circle实例的个数，并在④的位置编写语句用来统计Circle实例的个数。 （3）在⑤和⑥处根据注释语句填写代码 （4）在main()⑦的位置上编写语句调用Draw类中的drawSahpe()。 （5）将修改后的完整代码拷贝在下方： class Circle { //① private double radius = 0; ③ public Circle(double radius) { this.radius = radius; ④ } class Draw { //② public void drawSahpe() { ⑤ //输出radius变量的值 ⑥ //输出count变量的值 } } } public class OuterInnerClass { public static void main(String[] args) { ⑦ //编写语句调用Draw类中的drawSahpe() } } 答案： class Circle { //①外部类 private double radius = 0; static int count=0; public Circle(double radius) { this.radius = radius; count++; } class Draw { //②内部类
public void drawSahpe() { System.out.println(radius); System.out.println(count); } } } public class OuterInnerClass { public static void main(String[] args) { Circle objCircle=new Circle(10); Circle.Draw objDraw=objCircle.new Draw(); objDraw.drawSahpe(); } } 2.程序填空，使程序运行结果为 30 20 10 public class Demo{ public static void main (String[] args) { Outer.Inner obj=new Outer().new Inner(); obj.show(); } } class Outer{ public int number=10; class Inner{ public int number=20; public void show() { int number=30; System.out.print( ); System.out.print( ); System.out.print( ); } } } 答案： public class Demo{ public static void main (String[] args) { Outer.Inner obj=new Outer().new Inner(); obj.show();
第5章类的继承、包及接口 在前一章的实验中已经了解了类的基本构成、对象的创建及重载方法的应用等。本章实验的任务主要是了解Java中类的继承、类包、内部类、匿名类及接口的基本构成及应用。 5.1 实验一：类的继承 1. 实验目的 1）正确理解Java中类继承基本概念及思想； 2）基本掌握继承类和被继承类（子类和父类）之间的关系，正确地创建继承类。 2. 实验要求 正确地划分类，根据类之间的关系，确定父类和子类，掌握覆盖方法的应用，完成类程序的编写与调试。 3. 实验内容 在上一章的实验中，建立了公司职员信息类，现在需要处理职员的工资信息，建立职员工资类。 实验示例5.1.1 创建职员工资类Payroll类。 实现该示例的方法步骤如下： ⑴首先分析一下该类的构成 工资信息应包括职工的基本信息，因此可以把Employers类作为Payroll类的父类，Payroll类继承了父类所有的成员变量和方法，因此在Payroll类中需要定义的内容是： ①成员变量 对于工资信息项应该包括basicWage(基本工资)、positionWage(职位工资)、extraWage(附加工资)、other(其他补贴)等等。它们均可声明为int (整数类型)。 ②成员方法 常常需要显示或获得全部或某些项工资的信息，因此需要定义如下一些方法： display() 显示工资的全部信息； display(int value) 显示一项工资额； display(int value1, int value2) 显示两项工资额。 ③构造方法 如前所述，一个类能够有多个构造对象方法，视需要而定。对Payroll类来说可以给出两个构造方法： Payroll () 构造无名对象； Payroll(String ID,String name,String sex,String birthday,String home,String address, String number,int basicWage,int positionWage,int extraWage,int other) 构造一般对象。 ⑵根据上边分析和描述，按照类的构成，给出如下类程序代码： public class Payroll extends Employers { int basicWage; //定义基本工资 int positionWage; //定义职位工资 int extraWage; //定义附加工资
中的匿名内部类总结 匿名内部类也就是没有名字的内部类 正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写 但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口 实例1:不使用匿名内部类来实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat something"); } } public class Demo { public static void main(String[] args) { Person p = new Child(); p.eat(); } } 运行结果：eat something 可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person 类的引用 但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？ 这个时候就引入了匿名内部类 实例2：匿名内部类的基本实现 abstract class Person { public abstract void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println("eat something"); } }; p.eat(); } } 运行结果：eat something 可以看到，我们直接将抽象类Person中的方法在大括号中实现了 这样便可以省略一个类的书写
1. （分值：0.7 分）Java 语言中创建一个对象使用的关键字为 A: class B: interface C: new D: create 2. （分值：0.7 分）设有对象x 具有属性a 则访问该属性的方法为 A: a.x B: a.x() C: x.a D: x.a() 3. （分值：0.7 分）以public 修饰的类如：public class Car{…} 则Car( ) A: 可被其它程序包中的类使用 B: 仅能被本程序包中的类使用 C: 不能被任意其它类使用 D: 不能被其它类继承 4. （分值：0.7 分）Java 语言中，只限子类或者同一包中的类的方法能访问的访问权限是( ) A: public B: private C: protected D: <无修饰> 5. （分值：0.7 分）有Java 语句如下，则说法正确的是（）int ［］a,b=new int［3］; A: 此语句是错误的 B: a.length 的值为3 C: b.length 的值为3 D: a.length 和b.length 的值都为3 6. （分值：0.7 分）设有数组定义int[][] x={{1，2}，{3，4，5}，{6}，{}}；，则x.length 的值为( ) A: 3 B: 4 C: 6 D: 7 7. （分值：0.7 分）在Java 语言的java.util 包中，用于语言符号（单词）分析的类是（）A: stringTokenizer B: StringTokenizer C: ToKenizer D: tokenizer 8. （分值：0.7 分）接口的所有变量和方法分别默认为是（） A: final static 和public abstract B: final static 和public final C: public static 和public abstract D: public static 和public final 9. （分值：0.7 分）下列有关Java 的叙述错误的是（） A: 强类型语言 B: 与平台无关
实验七抽象类、接口与包 一、实验目的 1、熟练掌握抽象类abstract的概念。 2、熟练掌握接口interface的概念。 3、熟练包package的概念以及编译运行的方法。 二、实验内容与要求 1．编写求解几何图形（如三角形，矩型，圆，多边型）的周长、面积的应用程序，要求用到继承、多态、抽象类、接口、内部类等面向对象程序设计技术的特点。 2、重写上面的程序，要求三角形，矩型，圆，多边型的类放到不同的包中，用包的技术组织程序的设计。同时要求程序能从键盘上接受数据以便求解不同的几何图形的周长面积。提示：从键盘上输入双精度数的一种方法(程序片段) …… public static void main(String args[]) throws IOException { BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in)); String x; x=keyin.readLine(); double a=Double.parseDouble(x); …… ３．练习https://www.doczj.com/doc/049640427.html,ng.Class类的使用，通过一个对象返回一个Class对象，如何获取一个类的名称，如何使用class生成一个类的对象。获取类的描述信息。 4．从命令行输入一个正整数，用递归的方法求出每位数字上的累加和 5、编写一个应用程序，实现以下功能： ①声明一个接口(Calculability)，接口中包含一个方法area()。 ②声明一个三角形类继承该接口，类名为Triangle，类中包含两个变量、一个带参数年的构造方法和一个计算三角形面积的方法： 三角形的底边长w 三角形的高h 构造方法Triangle(double width,double height)。 计算三角形面积的方法area()，该方法覆盖接口(Calculability)的同名方法，计算三角形的面积（w*h/2）。 ③声明一个锥体类（Taper），包含一个接口对象bottom(锥体的底)和一个变量（锥体的高）height，一个带参数的构造方法，一个换底方法getbottom()，一个锥体体积的计算方法volume()。 ④声明一个主类Exp6_1，在主方法中声明接口和锥体类的对象，输出锥体的底面积和锥体的体积（bottom*height/3）。
实验报告 课程名称： Java程序设计成绩评定： 实验项目名称：接口、泛型、枚举、内部类与异常指导教师： 学生姓名：学号：专业班级： 实验项目类型：基础实验地点：实验时间： 一、实验目的与要求： 1、理解接口的定义与实现； 2、知道泛型、枚举型与内部类的基本应用； 3、掌握常用异常的抛出与捕获及处理. 二、实验环境：（硬件环境、软件环境） 1.硬件环境：奔ⅣPC。 2.软件环境：Windows XP 操作系统，JDK6.0。 三、实验内容：（原理、操作步骤、程序代码等） 任务： 1、按照要求完成下述接口及实现类的程序 1)定义名称为PCI（）的接口，包括启动的方法start和关闭的方法stop； 2)定义名称为NetworkCard 的类表示网卡，实现PCI接口，并且其在实现start 方法时输出“sending data……”，在实现stop方法时输出“network stop.” 3)定义名称为SoundCard 的类表示声卡，实现PCI接口；并且其在实现start 方法时输出“dudu……”，在实现stop方法时输出“sound stop.” 4)定义名称为MainBoard 的类表示主板，包含方法public void usePCICard(PCI p)，在方法体内通过p来启动和关闭组件； 5)定义一个包含main方法的Test类，在main方法内创建一个MainBoard 对 象用mb来引用，创建一个NetworkCard对象用nc来引用，创建一个 SoundCard对象用sc来引用，分别通过mb来使用usePCICard(PCI p)启动声 卡和网卡。 2、泛型类程序的调试 调试教材P165的程序8-2，写出程序运行结果，理解泛型类的工作机理及应用。 3、调试运行内部类程序： 在类内部再定义另外一个类，这个另外定义的类就叫内部类。调试教材P171-172程序8-3，写出程序运行结果，理解内部类的定义方法与应用。 4、异常抛出与捕获编程与调试 先调试教材P182、183中的程序9-2和9-3，写出调试结果。然后，自己编写一个能抛出并捕获、处理NullPointerException、NumberFormanException多异常的程序，并调试后写出运行结果。
1、课程名称：接口的定义及使用 2、知识点 2.1、上次课程的主要知识点 1、抽象类的设计是在普通类之上的抽象类； 2、抽象类关键的问题就是约定了子类必须要覆写的抽象方法； 3、抽象类的使用原则： ·抽象类必须有子类，子类利用extends关键字来继承抽象类，一个子类只能够继承一个父类； ·抽象类的子类（如果不是抽象类），那么必须要覆写抽象类中的全部抽象方法； ·抽象类可以利用对象的向上转型机制，通过子类对象进行实例化操作。 2.2、本次预计讲解的知识点 1、接口的基本定义以及使用形式； 2、与接口有关的设计模式的初步认识； 3、接口与抽象类的区别。
3、具体内容（★★★★★★★★★★★★★★） 接口与抽象类相比，接口的使用几率是最高的，所有的设计几乎都是围绕着接口进行的，但是要想把接口彻底闹明白，需要很长一段时间。 3.1、接口的基本概念 接口是一种特殊的类，但是在接口里面的组成与类不同，比类的组成部分简单，主要由抽象方法和全局常量所组成。而接口使用interface关键字来定义。 范例：定义一个接口 当一个接口定义完成之后，需要遵循如下的步骤进行接口的使用： ·接口一定要定义子类，子类利用implements关键字来实现接口，一个子类可以同时实现多个接口； |- 秒杀抽象类的单继承局限，一个抽象类只能够被一个子类所继承； ·接口的子类（如果不是抽象类）那么必须覆写接口中的全部抽象方法； ·接口的对象利用子类对象的向上转型进行实例化操作。 范例：使用接口
但是这个时候会有这样一种比较神奇的操作。 注意：关于接口的组成描述 接口里面在定义的时候就已经明确的给出了开发要求：抽象方法和全局常量，所以以下两种接口的定义从本质上讲是完全一样的。 如果在定义接口方法的时候没有使用public ，那么本质上也不是default 权限，而默认就是public 。 很多时候为了防止一些开发者概念不清晰，所以以后建议大家在定义接口的时候永远都写上public ，但是一般都不会去写abstract 。 现在程序之中出现有类、抽象类、接口，这几者之间的联系就需要注意好了。 一个普通类如果要实现接口又要求继承抽象类，则一定采用先extends 继承抽象类，再implements 实现接口。格式： 范例：观察子类的多继承
public class LocalInnerClassTest{ public static void main(String[] args{ Outer obj=new Outer(; //生成一个外部类对象 SuperInner si=obj.outer(; //调用外部类中的outer(方法，返回一个SuperInner类型对象赋值给si si.m1(; //调用被覆盖的方法m1(,输出：Inner's m1( 20 } } /** *定义一个接口SuperInner，内部定义一个抽象方法m1(,无返回类型 */ interface SuperInner{ public void m1(; } /** *定义一个类Outer，内部只定义一个方法outer(，返回类型为SuperInner */ class Outer{ public SuperInner outer({ int a=10; //方法中定义一个局部变量a，并赋值为10 final int b=20; //再定义一个final局部变量b，初始化为20 class Inner implements SuperInner{ //在outer(方法中定义一个局部内部类Inner,实现接口SuperInner public void m1({ //类中只有一个覆盖接口SuperInner的方法m1(
System.out.println("Inner's m1("+a; //编译报错 System.out.println("Inner's m1( "+b; //编译通过，输出：Inner's m1( 20 } } return new Inner(; } } 我们先从主方法开始看代码的执行顺序，先生成一个Outer类对象obj，obj调用本类中方法outer(；程序开始跳到outer(方法内执行程序语句，先后生成局部变量a和b,再定义一个局部内部类Inner，返回一个SuperInner类型的对象。将返回的SuperInner类型对象地址传给SuperInner类型对象si。si再调用m1(方法，因为已经在局部内部类中覆盖了接口中的m1(方法，所以将调用局部内部类中的m1(方法，程序跳到局部内部类中m1(方法内执行程序语句，先输出一段字符串和a，结果编译报错，先将这条程序语句隐藏，执行下面的语句，你会发现编译通过而且输出Inner's m1( 20！ 为什么会这样呢？大家都知道局部变量仅仅在一个范围内有效，在方法调用完就被内存释放，在Outer类对象obj调用outer(方法时，a和b才产生，调用结束后被内存释放，那么b这个值也就不复存在了，为什么还会输出20呢？难道局部变量被final修饰就不会被内存释放而保留？ 其实有部分操作对于程序员是透明的，那是JAVA语言开发者的小把戏，在定义a和b 时 JVM(JAVA虚拟机做了程序员看不到的操作，他将b拷贝了一份给局部内部类，也就是说JVM在局部内部类中定义了一个final int b=20；这个操作程序员是不知道的！当调用m1(方法时输出的20并不是原来outer(方法中定义的b，而仅仅是JVM拷贝的一个副本。那么为什么a没被打印出呢？那是因为JVM并没有拷贝它，因为没有final修饰，说明它可以被修改，如果把a 改为a++，此时JVM就不知道拷贝a还是a++了，所以对于无final修饰的局部变量JVM是不会拷贝传给局部内部类的，自然无法打输出！
1. （分值：分）Java 语言中创建一个对象使用的关键字为 A: class B: interface C: new D: create 2. （分值：分）设有对象x 具有属性a 则访问该属性的方法为 A: B: () C: D: () 3. （分值：分）以public 修饰的类如：public class Car{…} 则Car( ) A: 可被其它程序包中的类使用 B: 仅能被本程序包中的类使用 C: 不能被任意其它类使用 D: 不能被其它类继承 4. （分值：分）Java 语言中，只限子类或者同一包中的类的方法能访问的访问权限是( ) A: public B: private C: protected D: <无修饰> 5. （分值：分）有Java 语句如下，则说法正确的是（）int ［］a,b=new int［3］; A: 此语句是错误的 B: 的值为3 C: 的值为3 D: 和的值都为3 6. （分值：分）设有数组定义int[][] x={{1，2}，{3，4，5}，{6}，{}}；，则的 值为( ) A: 3 B: 4 C: 6 D: 7 7. （分值：分）在Java 语言的包中，用于语言符号（单词）分析的类是（） A: stringTokenizer B: StringTokenizer C: ToKenizer D: tokenizer 8. （分值：分）接口的所有变量和方法分别默认为是（） A: final static 和public abstract B: final static 和public final C: public static 和public abstract D: public static 和public final 9. （分值：分）下列有关Java 的叙述错误的是（） A: 强类型语言 B: 与平台无关
内部类详解 1、定义 一个类的定义放在另一个类的内部，这个类就叫做内部类。 Java代码 1.public class First { 2.public class Contents{ 3. public void f(){ 4. System.out.println("In Class First's inner Class Contents method f()") ; 5. } 6.} 7. } 像这样的，Contents就叫做内部类 内部类了解外围类，并能与之通信(后面详细讲) 2、链接到外围类 创建了内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件。 Java代码 1. public class First { 2.public class Contents{ 3. public void getStr(){ 4. System.out.println("First.str="+str); 5. } 6.} 7.private String str; 8. } 9. 在内部类Contents中，可以使用外围类First的字段str。 那么，它是如何实现的呢？ 是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，于是，可以通过这个引用来访问外围类的成员。 通常，这些都是编译器来处理，我们看不到，也不用关心这个。 正是因为如此，我们创建内部类对象时，必须与外围类对象相关联。
注：嵌套类(后面会讲到)除外。 3、使用关键字.this与.new 内部类中得到当前外围类对象的引用，可以使用.this关键字，注意与new的区别 Java代码 1. private int num ; 2.public Test2(){ 3. 4.} 5. 6.public Test2(int num){ 7. this.num = num; 8.} 9. 10.private class Inner{ 11. public Test2 getTest2(){ 12. return Test2.this; 13. } 14. 15. public Test2 newTest2(){ 16. return new Test2(); 17. } 18.} 19. 20.public static void main(String [] args){ 21. Test2 test = new Test2(5); 22. Test2.Inner inner = test.new Inner(); 23. Test2 test2 = inner.getTest2(); 24. Test2 test3 = inner.newTest2(); 25. System.out.println(test2.num); 26. System.out.println(test3.num); 27.} 28. 输出结果为5 0 使用.this后，得到时创建该内部类时使用的外围类对象的引用，new则是创建了一个新的引用。 .new关键字
序 抽象类的特点： 1，抽象方法一定在抽象类中。 2，抽象方法和抽象类都必须被abstract关键字修饰。 3，抽象类不可以用new创建对象。因为调用抽象方法没意义。 4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。 如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。 抽象类和一般类没有太大的不同。 抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。 抽象类不可以实例化。 特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。 abstract 关键字，和哪些关键字不能共存。 final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。 private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。 而抽象方法出现的就是需要被复写。 static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。 可是抽象方法运行没意义。 抽象类中有构造函数,因为抽象类是一个父类，要给子类提供实例的初始化。 继承： 1，提高了代码的复用性。 2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。 注：不要为了获取其他类的功能，简化代码而继承。 必须是类与类之间有所属关系才可以继承。所属关系 is a。 Java语言中：java只支持单继承，不支持多继承。 因为多继承容易带来安全隐患:当多个父类中定义了相同功能， 当功能内容不同时，子类对象不确定要运行哪一个。 但是java保留这种机制。并用另一种体现形式来完成表示。多实现。 java支持多层继承。也就是一个继承体系
最近看到论坛里有个帖子在讨论接口和抽象类的区别和作用，这其实也是很多面试官喜欢问的问题，这里我就说说我的总结，顺便说说内部类的作用，当是给刚入门，或者想学习jav a的同学们能更好的理解它们的用法。 2.抽象类(abstract class)，只要类中有一个抽象方法，此类就被标记为抽象类。实际上抽象类 除了被继承之外没有任何意义。 区别 1. 接口是公开(public)的，里面不能有私有的方法或变量,是用于让别人使用的,实现接口的一定 要实现接口里定义的所有方法。 而抽象类是可以有私有方法或私有变量的，实现抽象类可以有选择地重写需要用到的方法， 但是必须实现里面所有的抽象方法。 2. 抽象类在Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。 但是，一个类却可以实现多个interface(java中实现多重继承的方法之一)。 3. 抽象类中可以有自己的数据成员，也可以有非abstarct的成员方法。 而在接口中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），而且所有的成员方法都是抽象的。 4. 抽象类和接口所反映出的设计理念不同。 其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。（组合是"has a"关 系） 5.
接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新 定义，也不能改变其值。 抽象类中的变量默认是friendly 型，其值可以在子类中重新定义，也可以重新赋值。 一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。不是很建议具体类直接实现接口的。还有一种设计模式是面向接口编程，而非面向实现编程。 其实接口是抽象类的延伸，可以将它看做是纯粹的抽象类，就是说接口比抽象类还抽象，还有设计接口的目的就是为了实现C++中的多重继承，不过java团队设计的一样更有趣的东西来实现这个功能，那就是内部类(inner class)。 一.定义 放在一个类的内部的类我们就叫内部类。 二.作用 1.内部类可以很好的实现隐藏,也就是封装性。一般的非内部类，是不允许有private 与prot ected权限的，但内部类可以 2.内部类拥有外围类的所有元素的访问权限 3.可是实现多重继承(这个特点非常重要，个人认为它是内部类存在的最大理由之一) 4.可以避免修改接口而实现同一个类中两种同名方法的调用 三.多重继承的实现
实验四接口和内部类 一、实验目的：熟悉JA V A中的接口、内部类、匿名类、异常类的概念及用法。 二、实验要求： 1.设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声，要求如下： ●编写接口Animal Animal接口有2个抽象方法cry()和getAnimalName()，即要求实现该接口的各种具体的动物给出自己的叫声和种类名称。 ●编写模拟器类Simulator 该类有一个playSound(Animal animal)方法，该方法的参数是Animal类型。即参数animal 可以调用实现Animal接口类重写的cry()方法播放具体动物的声音，调用重写的getAnimalName()方法显示动物种类的名称。 ●编写实现Animal接口的类：Dog和Cat类 各类的UML图如下所示： 在各类中通过构造方法实现对成员变量的初始化。 ●编写主类Application（用户程序） 在主类Application的main方法中至少包含如下代码。 Simulator simulator = new Simulator(); simulator.playSound(new Dog(“藏獒”)); simulator.playSound(new Cat(“加菲猫”)); 2．评价成绩：体操比赛计算选手成绩的办法是去掉一个最高分和最低分后再计算平均分，而学校考察一个班级的某科目的考试情况时，是计算全班同学的平均成绩。Gymnastics类和School类都实现了接口ComputerAverage接口，但实现的算法不同。 编写Java程序实现以上功能。
3．货车的装载量：货车要装载一批货物，货物由三种商品组成：电视、计算机和洗衣机。卡车需要计算出整批货物的重量。 要求有一个ComputeGoodsWeight接口，该接口中有一个方法： public double computeWeight() 有三个实现该接口的类：Television、Computer和WashMachine。这三个类通过实现接口的computeWeight()方法给出自重。 有一个Truck类，该类用ComputeGoodsWeight接口类型的数组作为成员（Truck类面向接口），那么该数组的单元就可以存放Television对象的引用、Computer对象的引用或WashMachine对象的引用。程序能输出Truck对象所装载的货物的总重量。 4．手机专卖店为了促销自己的产品，决定发行内部购物券，但其他商场不能发行该购物券。编写一个MobileShop类（模拟手机专卖店），该类中有一个名字为InnerPurchaseMoney 的内部类（模拟内部购物券）。 程序模板：请按模板要求，将代码替换为Java程序代码。 NewYear.java class MobileShop{ 代码1 //用内部类InnerPurchaseMoney声明对象purchaseMoney1 代码2 //用内部类InnerPurchaseMoney声明对象purchaseMoney2 private int mobileAmount; //手机数量 MobileShop(){ 代码3 //创建价值为20000的purchaseMoney1 代码4 //创建价值为10000的purchaseMoney2 } void setMobileAmount(int m){ mobileAmount=m; } int getMobileAmount(){ return mobileAmount; } class InnerPurchaseMoney{ int moneyValue; InnerPurchaseMoney(int m){ moneyValue=m; } void buyMobile(){ if(moneyValue>=20000){ mobileAmount=mobileAmount-6; System.out.println(“用价值”+moneyValue+”的内部购物券买了3部手机”); } else if(moneyValue<20000&&moneyValue>=10000){ mobileAmount=mobileAmount-3;
面向对象编程基本知识练习 一、判断题 1.不需要定义类，就能创建对象。（） 2.构造方法用于给类的private 实例变量赋值。（） 3.对象一经声明就可以立即使用。（） 4.在定义变量和方法时，必须清楚地在其面前标上访问权限修饰符。（） 5.Java 程序中的参数传递都是把参数值传递给方法定义中的参数。（） 6.在类定义中，成员访问权限修饰符不能多次出现。（） 7.new 操作符动态地为对象按其指定的类型分配内存，并返回该类型的一个引用。（） 8.类的方法通常设为public，而类的实例变量一般也设为public。（） 9.构造方法在创建对象时被调用。（） 10.通过点运算符与类对象的引用相连，可以访问此类的成员。（） 11.声明为protected 的类成员只能被此类中的方法访问。（） 12.同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。（） 13.类的成员变量可以放在类体的任意位置。（） 14.声明为protected 的类成员可以被此类作用域中的任何对象访问。（） 15.没有返回值的方法可以用void 来表示，也可以不加。（） 二、选择题 1. 下面对对象概念描述错误的是：( ) A 操作是对象的动态属性 B 任何对象都必须有继承性 C 对象间的通讯靠消息传递 D 对象是属性和方法的封装体 2．编译并运行下面的程序，运行结果为：( ) public class A { public static void main(String[] args) { A a=new A()； a.method(8)； } void method(int i) { System.out.println(“int：“+i)； } void method(long i) { System.out.println(“long：“+i)； } } A 程序可以编译运行，输出结果为int：8 B 程序可以编译运行，输出结果为long：8
实验五抽象类、接口与包 一、实验目的 1、熟练掌握抽象类abstract的概念。 2、熟练掌握接口interface的概念。 3、熟练包package的概念以及编译运行的方法。 4、熟练掌握内部类inner class的概念。 5、熟练掌握递归的概念。 6、理解面向对象的程序设计方法。 二、实验内容与要求 1．编写求解几何图形（如三角形，矩型，圆，多边型）的周长、面积的应用程序，要求用到继承、多态、抽象类、接口、内部类等面向对象程序设计技术的特点。 2、重写上面的程序，要求三角形，矩型，圆，多边型的类放到不同的包中，用包的技术组织程序的设计。同时要求程序能从键盘上接受数据以便求解不同的几何图形的周长面积。提示：从键盘上输入双精度数的一种方法(程序片段) …… public static void main(String args[]) throws IOException { BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in)); String x; x=keyin.readLine(); double a=Double.parseDouble(x); …… ３．练习https://www.doczj.com/doc/049640427.html,ng.Class类的使用，通过一个对象返回一个Class对象，如何获取一个类的名称，如何使用class生成一个类的对象。获取类的描述信息。 4、编写一个应用程序，实现以下功能： ①声明一个接口(Calculability)，接口中包含一个方法area()。 ②声明一个三角形类继承该接口，类名为Triangle，类中包含两个变量、一个带参数的构造方法和一个计算三角形面积的方法： 三角形的底边长w 三角形的高h 构造方法Triangle(double width,double height)。 计算三角形面积的方法area()，该方法覆盖接口(Calculability)的同名方法，计算三角形的面积（w*h/2）。 ③声明一个锥体类（Taper），包含一个接口对象bottom(锥体的底)和一个变量（锥体的高）height，一个带参数的构造方法，一个换底方法getbottom()，一个锥体体积的计算方法volume()。
JAVA上机实验 实验名称：抽象类、接口与内部类 实验目的：掌握抽象类、接口的定义、实现与使用; 掌握内部类的创建；理解接口和继承的混合使用。 一、实验内容： ?1、定义接口Shape，其中包括一个方法size（）,设计“矩形”、“圆”、“圆柱体”等类实现Shape接口,其size（）方法分别表示计算矩形面积、圆面积、圆柱体的体积。分别创建代表“矩形”、“圆”、“圆柱体”的三个对象存入一个Shape类型的数组中，通过调用size （）方法将数组中各类图形的大小输出。 注意： 1、实现接口方法一定要与接口方法相同， 在对它进行修改，即重写（保证返回值类型、方法名、方法的基本类型相同，否则会出现错误：未添加接口方法或定义类为抽象） 2、创建接口方法时，不存在方法体的，即后面大括号的部分 3、Java中求函数的幂：Math.pow(x,y); 例如：Math.pow(3,2); 解释:3的2次方 4、我的疑问： （1）如何将数组中的内容全部输出 （2）如何在接口对象中输出类中的属性值: 需要进行强制转可以输出类中的属性 例：Shape s[]=new Shape(); S[0]=new Juxing(); Juxing k =(Juxing) s[0]; package test; public interface Shape { //创建接口方法 public double size(); } package test; public class Juxing implements Shape { //属性 double length;//矩形的长 double width;//矩形的宽 double height;//矩形的高 //创建构造方法 public Juxing(double l,double w,double h){ this.length=l; this.width=w; this.height=h; } //实现接口的方法