Java零基础系列课程-JavaSE基础篇
Lecture：波哥
Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。
面向对象练习题
一、填空题
1．如果一个方法不返回任何值，则该方法的返回值类型为( void ) 。
2．如果子类中的某个方法名、返回值类型和( 访问权限修饰符 )与父类中的某个方法完全一致，则称子类中的这个方法覆盖了父类的同名方法。
3．接口中所有的属性均为( public )( final )和 ( static )的
4． ( 抽象方法 )方法是一种仅有方法声明，没有具体方法体和操作实现的方法，该方法必须在 ( 抽象 )类，( 接口 )类之中定义。
5．在Java程序中，通过类的定义只能实现( 单 )重继承，但通过( 接口 )的定义可以实现多重继承关系。
6． 一般Java程序的类主体由两部分组成：一部分是( 成员变量 )，另一部分 是( 成员方法 ) 。
7． 分别用( class )关键字来定义类，用( new )关键字来分配实例存储空间。
8． 当一个类的修饰符为( final )时，说明该类不能被继承，即不能有子类。
9．在Java中，能实现多重继承效果的方式是( 接口 ) 。
二、选择题
-
方法内定义的变量（ B ）。
A．一定在方法内所有位置可见 B．可能在方法的局部位置可见
C．在方法外可以使用 D．在方法外可见 -
方法的形参（ A ）。
A．可以没有 B．至少有一个
C．必须定义多个形参 D．只能是简单变量 -
return语句（C ）
A．不能用来返回对象 B．只可以返回数值
C．方法都必须含有 D．一个方法中可以有多个 -
main()方法的返回值类型是（ C ）
A．boolean B．int
C．void D．static -
编译并运行下面的程序，运行结果是（ A ）。
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”
C．程序有编译错误，因为两个method()方法必须定义为静态（static）的
D．程序可以编译运行，但是没有输出 -
能作为类及其成员的修饰符是（D ）。
A．interface B．class
C．protected D．public -
下列方法定义中，方法头不正确的是（A ）。
A．public static x(double a){} B．public static int x(double y){}
C．void x(double d){} D．public int x(){} -
构造方法在（ D ）时被调用。
A．类定义时 B．使用对象的变量时
C．调用对象方法时 D．创建对象时 -
下列哪个类声明是正确的（ A ）。
A．public abstract class Car{} B．abstract private move(){}
C．protected private number; D．abstract final class H1{} -
下列不属于面向对象程序设计的基本特征的是（ D ）。
A．抽象 B．封装
C．继承 D．静态 -
请看下面的程序段 那个选项可以添加到// doing the same处（ C ）
class Person{ String name,department; int age; public Person(String n){name=n;} public Person(String n, int a){name=n; age=a;} public Person(String n, String d, int a ){ //doing the same as two arguments version if constructer }A．Person(n,a) B．this(Person(n,a))
C．this(n, a) D．this(name.age) -
请看下面的程序段 方法fun()如何来访问变量m（ C ）
class Test{ private int m; public static void fun(){ //some code } }A．将private int m 改成protected int m B．将private int m 改成public int m
C．将private int m 改成static int m D．将private int m 改成int m -
有一个类A，对于其构造函数的声明正确的是（ B ）。
A．void A(int x){} B．public A(int x){}
C．A A(int x){} D．int A(int x){} -
请看下面的程序段 哪一个选项是正确的（ C ）
public class Test{ long a[]=new long[10]; pubic static void main(String args[]){ System.out.println(a[6]); } }A．不输出任何内容 B．输出0
C．当编译时有错误出现 D．当运行时有错误出现 -
关键字（B ）表明一个对象或变量在初始化后不能修改。
A．extends B．final
C．this D．finalize -
声明为static的方法不能访问（ C ）类成员。
A．超类 B．子类
C．非static D．用户自定义类 -
定义类A如下下面对方法B的重载哪些是正确的（ C ）。
class A{ int a,b,c; public void B(int x,int y, int z){ a=x;b=y;c=z;} }A．public void A(int x1,int y1, int z1){ a=x1;b=y1;c=z1;}
B．public void B(int x1,int y1, int z1){ a=x1;b=y1;c=z1;}
C．public void B(int x,int y){ a=x;b=y;c=0;}
D．public B(int x,int y, int z){ a=x;b=y;c=z;} -
编译运行下面的程序，结果是（ B ）。
public class A{ public static void main(String args[]){ B b=new B(); b.test(); } void test(){ System.out.print("A"); } } class B extends A{ void test(){ super.test(); System.out.print("B"); } }A．产生编译错误 B．代码可以编译运行，并输出结果：AB
C．代码可以编译运行，但没有输出 D．编译没有错误，但会产生运行时异常 -
已知类关系如下，下列语句正确的是：（ A ）
Class Employee{}
Class Manager extends Employee{}
Class Director extends Employee{}
。
A．Employee e=new Manager(); B．Director d=new Manager();
C．Director d =new Employee (); D．Manager m=new Director (); -
接口是Java面向对象的实现机制之一，以下说法正确的是（ B ）。
A．Java支持多重继承，一个类可以实现多个接口
B．Java只支持单重继承，一个类可以实现多个接口
C．Java只支持单重继承，一个类可以实现一个接口
D．Java支持多重继承，但一个类只可以实现一个接口 -
下列方法的声明中不合法的是（ C ）。
A．float area( ){} B．void area( ){}
C．area{…} D．int area(int r){…} -
下面哪个包是编程时不需要导入就可以直接使用的（ B ）。
A．java.net B．java.lang C．java.sql D．java.util -
在子类构造方法的哪个地方可以调用其父类的构造方法（ B ）。
A．任何地方
B．构造方法的第一条语句
C．构造方法的最后一条语句
D．无法在子类构造方法中调用父类的构造方法 -
关于Java中的继承，下列说法错误的是（ D ）。
A．继承是面向对象编程的核心特征，通过继承可以更有效地组织程序结构。
B．继承使得程序员可以在原有类的基础上很快设计出一个功能更强的新类，而不必从头开始，避免了工作上的重复。
C．每一次继承时，子类都会自动拥有父类的属性和方法，同时也可以加入自己的一些特性，使得它更具体、功能更强大。
D．继承一般有多重继承和单一继承两种方式，在单一继承中每一个类最多只有一个父类，而多重继承则可以有多个父类。Java中的类都采用多重继承。 -
当方法中的局部变量与成员变量同名时，必须使用下列哪一个关键字指出成员变量（ C ）。
A．static B．super C．this D．new -
什么样的方法不能被重写（ D ）。
A．私有（private）方法 B．最终（final）方法
C．受保护（protected）的方法 D．以上都不对 -
下列有关抽象类与接口的叙述中正确的是哪一个（ C ）。
A．抽象类中必须有抽象方法，接口中也必须有抽象方法
B．抽象类中可以有非抽象方法，接口中也可以有非抽象方法
C．含有抽象方法的类必须是抽象类，接口中的方法必须是抽象方法
D．抽象类中的变量定义时必须初始化，而接口中不是 -
从下列程序中你发现了几处错误（ D ）。
abstract class A{ abstract void f(){}; // 1 public abstract void k(); } class B extends A{ protected void f(){ } // 2 void k(){ // 3 System.out.print("I am subclass"); } public static void main(String[] args) { A a=new A(); // 4 a.f(); a.k(); } }A．1 B．2 C．3 D．4
-
下列程序运行的结果是 （ A ）。
interface InterfaceA{ String s="good "; void f(); } class ClassA implements InterfaceA{ public void f(){ System.out.print(s); } } class ClassB{ void g(InterfaceA a){ a.f(); } } public class E { public static void main(String[] args) { ClassB b=new ClassB(); b.g(new ClassA()); } }A．good B．编译正确，但无运行结果
C．编译错误：b.g(new ClassA()) D．以上都不对 -
下列类的声明中不合法的是（ A ）。
A．class People（）{…} B．class 植物{…}
C．class A{…} D．public class 共有类{…} -
能作为类的修饰符, 也能作为类成员的修饰符的是 A 。
A．public B．extends C．Float D．static -
试完成下述程序片段 （ B ）。
public class Point{ int x,y; public Point(int x,int y){ ( )=x; ( )=y; } ...... }A．Point.x Point.y B．this.x this.y
C．super.x super.y D．无解 -
在JAVA 中，下列说法正确的是（ C ）。
A．一个子类可以有多个父类，一个父类也可以有多个子类
B．一个子类可以有多个父类，但一个父类只可以有一个子类
C．一个子类只可以有一个父类，但一个父类可以有多个子类
D．上述说法都不对 -
Father和Son是两个java类，下列哪一选项正确的标识出Father是Son的父类？D
A．class Son implements Father B．class Father implements Son
C．class Father extends Son D．class Son extends Father -
重载指的是方法具有相同的名字，但这些方法的参数必须不同。下列哪种说法不属于方法参数的不同（ C ）。
A．形式参数的个数不同。 B．形式参数的类型不同。
C．形式参数的名字不同。 D．形式参数类型的排列顺序不同。 -
关于接口的定义和实现，以下描述正确的是 （ A ）。
A．接口定义的方法只有定义没有实现
B．接口定义中的变量都必须写明final和static
C．如果一个接口由多个类来实现，则这些类在实现该接口中的方法时采用统一的代码
D．如果一个类实现接口，则必须实现该接口中的所有方法，但方法未必申明为public -
以下关于构造方法的说法，正确的是（ D ）
A．构造方法可以和类名不一致
B．一个类中只能定义一个构造方法
C．如果类中没有定义构造方法，则不能实例化该类对象
D．一个类可以定义多个构造方法，但这些构造方法的参数列表必须不同 -
下面Java代码的运行结果是（ D ）。
class Penguin { private String name=null; // 名字 private int health=0; // 健康值 private String sex=null; // 性别 public void Penguin() { health = 10; sex = "雄"; System.out.println("执行构造方法。"); } public void print() { System.out.println("企鹅的名字是" + name + "，健康值是" + health + "，性别是" + sex+ "。"); } public static void main(String[] args) { Penguin pgn = new Penguin(); pgn.print(); } }A. 企鹅的名字是null，健康值是10，性别是雄。
B. 执行构造方法。
企鹅的名字是null，健康值是0，性别是null。
C. 企鹅的名字是null，健康值是0，性别是null。
D. 执行构造方法。
企鹅的名字是null，健康值是10，性别是雄。 -
下列选项中关于Java中封装的说法错误的是（ D ）。
A. 封装就是将属性私有化，提供公有的方法访问私有属性
B. 属性的访问方法包括setter方法和getter方法
C. setter方法用于赋值、getter方法用于取值
D. 类的属性必须进行封装，否则无法通过编译 -
使用Java实现封装，第一步是修改属性可见性来限制对属性的访问，第二步是
创建赋值和取值方法，用于对属性的访问，第三步应该是（ C ）。
A. 使用赋值和取值方法访问属性
B. 编写常规方法访问属性
C. 在赋值和取值方法中，加入对属性的存取限制
D. 编写main方法创建对象，调用赋值和取值方法访问属性
三、阅读程序题
-
写出运行结果： 。
public class Computer{ String mainbord,cpu; public Computer(String s1,String s2){ mainbord=s1; cpu=s2; } public static void main(String[]args){ Computer c=new Computer("华硕","Intel"); System.out.println("mainbord:"+c.mainbord+",cpu:"+c.cpu); } }mainbord:华硕，CPU:Intel
-
写出运行结果： 。
public class Person{ String name; int age; public Person(String name,int age){ this.name=name; this.age=age; } public static void main(String[]args){ Person c=new Person("Peter",17); System.out.println(c.name+" is "+c.age+" years old!"); } }Peter is 17 years old！
-
写出运行结果： 。
public class Abc{
public static void main(String args[ ]) {
SubSubClass x = new SubSubClass(10 , 20 , 30);
x.show();
}
}
class SuperClass{
int a,b;
SuperClass(int aa , int bb){
a=aa; // 10
b=bb; // 20
}
void show( ){
System.out.println("a="+a+" b="+b);
}
}
class SubClass extends SuperClass{
int c; // 30
SubClass(int aa,int bb,int cc){
super(aa,bb); // 10 20
c=cc; // 30
}
}
class SubSubClass extends SubClass{
int a; // 60
SubSubClass(int aa,int bb,int cc){
super(aa,bb,cc); // 10 20 30
a=aa+bb+cc;// 60
}
void show(){
System.out.println("a="+a+" b="+b+" c="+c);
}
}
a=60 b= 20 c=30
- 下面是一个类的定义，请将其补充完整
class _Student____{
String name;
int age;
Student(_String____ name, int a){
this.name=name;
age=a;
}
}
- 下面是一个类的定义，请将其补充完整
class _A____{
String s;
_static____ int a=3;
A(String s){
this.s=s;
}
static int getA(){
return a;
}
}
注：按Java规范书写程序代码，如果你认为程序有错误，请指出，并说明程序错误原因。
====================================================================
- 写出程序结果
6. class Test
{
Test()
{
System.out.println("Test");
}
}
class Demo extends Test
{
Demo()
{
System.out.println("Demo");
}
public static void main(String[] args)
{
new Demo();
new Test();
}
}
Test
Demo
Test
====================================================================
- 写出程序结果
interface A{}
class B implements A
{
public String func()
{
return "func";
}
}
class Demo
{
public static void main(String[] args)
{
A a=new B();
System.out.println(a.func());
}
}
编译报错
====================================================================
- 写出程序结果
class Fu
{
boolean show(char a)
{
System.out.println(a);
return true;
}
}
class Demo extends Fu
{
public static void main(String[] args)
{
int i=0;
Fu f=new Demo();
Demo d=new Demo();
for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
{
i++;
d.show('D');
}
}
boolean show(char a)
{
System.out.println(a);
return false;
}
}
A
B
====================================================================
- 写出程序结果
interface A{}
class B implements A
{
public String test()
{
return "yes";
}
}
class Demo
{
static A get()
{
return new B();
}
public static void main(String[] args)
{
A a=get();
System.out.println(a.test());
}
}
编译报错
====================================================================
- 写出程序结果:
class Super
{
int i=0;
public Super(String a)
{
System.out.println("A");
i=1;
}
public Super()
{
System.out.println("B");
i+=2; // i = 2
}
}
class Demo extends Super
{
public Demo(String a)
{
System.out.println("C");
i=5;
}
public static void main(String[] args)
{
int i=4;
Super d=new Demo("A");
System.out.println(d.i);
}
}
B
C
5
====================================================================
interface Inter
{
void show(int a,int b);
void func();
}
class Demo
{
public static void main(String[] args)
{
//补足代码；调用两个函数，要求用匿名内部类
new Inter(){
void show(int a,int b){
// ....
}
void func(){
// ...
}
}.show();
new Inter(){
void show(int a,int b){
// ....
}
void func(){
// ...
}
}.func();
}
}
====================================================================
- 写出程序结果
class TD
{
int y=6;
class Inner
{
static int y=3;
void show()
{
System.out.println(y);
}
}
}
class TC
{
public static void main(String[] args)
{
TD.Inner ti=new TD().new Inner();
ti.show();
}
}
编译报错。原因是在成员内部类中我们不能声明静态的属性和方法，但是可以声明静态的常量和final修饰的方法
3
====================================================================
-
选择题，写出错误答案错误的原因，用单行注释的方式。
class Demo { int show(int a,int b){return 0;} }下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;} // 参数列表完全一样
B.private int show(int a,int b){return 0;} // 重载和访问权限修饰符没有关系
C.private int show(int a,long b){return 0;} // 参数列表完全一样 int 可以自动转换为long类型
D.public short show(int a,int b){return 0;} // 重载和方法的返回结果没有关系
E.static int show(int a,int b){return 0;} // 重载和static同样没有关系
====================================================================
- 写出this关键字的含义，final有哪些特点？
this关键字表示的当前对象，可以通过this关键字获取当前对象相关的属性和方法
final关键字表示最终的含义
final修饰类：表示类不能被继承
final修饰方法：表示方法不能被重写
final修饰变量：表示变量被赋值后不能被修改，常量
====================================================================
- 写出程序结果：
class Fu
{
int num=4;
void show()
{
System.out.println("showFu");
}
}
class Zi extends Fu
{
int num=5;
void show()
{
System.out.println("showZi");
}
}
class T
{
public static void main(String[] args)
{
Fu f=new Zi();
Zi z=new Zi();
System.out.println(f.num); // 4
System.out.println(z.num); // 5
f.show(); // showZi
z.show(); // showZi
}
}
====================================================================
interface A
{
void show();
}
interface B
{
void add(int a,int b);
}
class C implements A,B
{
//程序代码
private int a,b;
//private int sum;
public void add(int a,int b)
{
this.a =a;
this.b = b;
//sum = a+b;
}
public void show()
{
System.out.println(a+b);
//System.out.println(sum);
}
}
class D
{
public static void main(String[] args)
{
C c=new C();
c.add(4,2);
c.show();//通过该函数打印以上两个数的和。
}
}
====================================================================
- 写出程序结果
class Demo
{
public static void main(String[] args)
{
try
{
showExce();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
finally
{
System.out.println("C");
}
System.out.println("D");
}
public static void showExce()throws Exception
{
throw new Exception();
}
}
====================================================================
- 写出程序结果
class Super
{
int i=0;
public Super(String s)
{
i=1;
}
}
class Demo extends Super
{
public Demo(String s)
{
super();
i=2;
}
public static void main(String[] args)
{
Demo d=new Demo("yes");
System.out.println(d.i);
}
}
编译报错
====================================================================
class Super{
public int get(){return 4;}
}
class Demo15 extends Super
{
public long get(){return 5;}
public static void main(String[] args)
{
Super s=new Demo15();
System.out.println(s.get()); // 5
}
}
====================================================================
- 写出程序结果：
class Demo
{
public static void func()
{
try
{
throw new Exception();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try
{
func();
}
catch(Exception e)
{
System.out.println("C");
}
System.out.println("D");
}
}
====================================================================
class Demo
{
public void func()
{
//位置1；
new Inner();
}
class Inner{}
public static void main(String[] args)
{
Demo d=new Demo();
// 位置2
new Inner();
}
}
A.在位置1写 new Inner(),可不可以？不可以写出原因; 可以
B.在位置2写 new Inner(),可不可以？不可以写出原因; 不可以 new Demo().new Inner();
C.在位置2写 new d.Inner(),可不可以？不可以写出原因; 不可以
D.在位置2写 new Demo.Inner(),可不可以？不可以写出原因; 不可以
====================================================================
-
写出程序结果
22. class Exc0 extends Exception{} class Exc1 extends Exc0{} class Demo { public static void main(String[] args) { try { throw new Exc1(); } catch(Exception e) { System.out.println("Exception"); } catch(Exc0 e) { System.out.println("Exc0"); } } }
====================================================================
interface Test
{
void func();
}
class Demo
{
public static void main(String[] args)
{
//补足代码；(匿名内部类)
new Demo().show(new Test(){
void func(){
// ....
}
});
}
void show(Test t)
{
t.func();
}
}
====================================================================
24.
写出程序结果
class Test
{
public static String output="";
public static void foo(int i)
{
try
{
if(i==1)
throw new Exception();
output+="1";
}
catch(Exception e)
{
output+="2";
return;
}
finally
{
output+="3";
}
output+="4";
}
public static void main(String args[])
{
foo(0);
System.out.println(output);
foo(1);
System.out.println(output);
}
}
写出程序结果
public class Demo
{
private static int j = 0;
private static boolean methodB(int k)
{
j += k; // 4
return true;
}
public static void methodA(int i)
{
boolean b;
b = i < 10 | methodB (4); // true
b = i < 10 || methodB (8); // true
}
public static void main (String args[] )
{
methodA (0);
System.out.println(j); // 4
}
}
====================================================================
四、编程题
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
一、1、请定义一个名为Card的扑克牌类，该类有两个private访问权限的字符串变量face和suit：分别描述一张牌的牌面值（如：A、K、Q、J、10、9、…、3、2等）和花色（如：“黑桃”、“红桃”、“梅花"和"方块”）。定义Card类中的public访问权限的构造方法，为类中的变量赋值；定义protected访问权限的方法getFace()，得到扑克牌的牌面值; 定义protected访问权限的方法getSuit()，得到扑克牌的花色; 定义方法toString()，返回表示扑克牌的花色和牌面值字符串（如"红桃A"、"梅花10"等）。
2.若应用程序的main方法中，定义字符串数组f和s: 分别表示扑克牌的牌面值和花色；定义52个元素的Card类型数组deck，用来存放4个花色的52张牌。如下所示。 String f[] = { “A”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “J”, “Q”, “K” }; String s[] = { “黑桃”, “红桃”, “梅花”, “方块” }; Card deck = new Card[ 52 ]; （1）使用Card类的构造方法给deck数组的52张牌赋值，要求数组中先存放黑桃花色的A、2、3、…、K；然后是红桃花色的A、2、3、…、K；梅花花色的A、2、3、…、K；方块花色的A、2、3、…、K。请写出实现上述功能的程序段。
（2）请编写模拟洗牌的程序段，即把数组deck中的扑克牌随机打乱存放顺序。
二、输入某年某月某日，判断这一天是这一年的第几天？（程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天。）
三、打印出杨辉三角形（要求打印出10行如下图）
1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1
四、某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换
五、有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
六、输入一个五位数判断是不是回文数。即12321是回文数，有能力同学试试看判断判断任意一个正数是不是回文数。
七、已知养猪场里有五头猪，分别是小花，旺财，来福，小黑，隔壁老王
使用数组存储这五只猪 （提示：对象数组）
每只猪有姓名，年龄，体重的属性
要求完成如下功能
1）求出所有猪的体重之和
2）找出最重的那头猪并输出它的名字和体重
3）对所有猪按照体重按照从小到大进行排序(要求至少使用选择和冒泡两种方式)
4）要求对排好序的猪进行遍历输出每一头猪的姓名，年龄，体重
八、编写下列程序
（1）创建Rectangle类，添加属性width、height；
（2）在Rectangle类中添加两种方法计算矩形的周长和面积；
（3）编程利用TestRectangle类输出一个矩形的周长和面积
九、设计一个系统：
XXX门的实现过程：
流程：
设计一张抽象的门Door，那么对于这张门来说，就应该
拥有所有门的共性，开门openDoor()和关门
closeDoor()；然后对门进行另外的功能设计,防盗–
theftproof()、防水–waterproof()、防弹–
bulletproof()、防火、防锈……
要求：利用继承、抽象类、接口的知识设计该门
十、使用面向对象思想和数组实现图书管理系统
![[linux网络编程]UDP协议和TCP协议的使用](https://img-blog.csdnimg.cn/direct/3570e8b110374bacbde0e04828dd6848.png)
