java期末考试题目归纳总结

2023-12-14 08:47:16

不能用来修饰 interface的有 private、protected、static（仅限外部接口）
一个java源文件中定义几个类和接口，则编译该文件后生成几个以 .class为后缀的字节码文件
List、Set继承来自 Collection接口
类可以实现多个接口，接口可以继承（或拓展）多个接口
Collection是java.util下的接口，它是各种集合结构的父接口
Collection是java.util下的接口，它是各种集合结构的父接口

若 a 的值为 3 时，下列程序段被执行后， c 的值是多少（)

int c = 1;
if ( a>0 ){
    if ( a>3){
        c = 2;
    }
    else{
        c = 3;
    }
}
else{
    c = 4;
}
//c=2

程序的运行结果是（）

public class IfTest{
    public static void main(String[] args){
        int x=3;
        int y=1;
        if(x=y)
            System.out.println("Not equal");
        else
            System.out.println("Equal");
     }
}
//程序的运行结果为:An error at line 5 causes compilation to fall.

下面选项中，哪些是 interface中合法方法定义 public void main(String [] args);、public float get(int x);
在java7中，下列不能做switch()的参数类型是浮点型

下面的switch语句中，x可以是哪些类型的数据

switch(x)
{
	default:
	System.out.println("Hello");
}
//byte

在接口中定义的方法除了default和static关键字修饰的方法拥有方法体，其他方法都应是没有方法体的抽象方法（JDK1.8以后）
一个java类只能有一个父亲但可以实现多个接口
定义接口时使用implements关键字
仅包含方法定义和常量值是接口
定义一个接口必须使用的关键字是interface

下面的方法，当输入2的时候返回值是多少？

public static int getValue(int i) {
	int result = 0;
	switch (i) {
		case 1:
		result = result + i;
		case 2:
		result = result + i * 2;
		case 3:
		result = result + i * 3;
	}
	return result;
}
//10

实现或继承了Collection接口的是 List
接口可以拓展（继承）多个接口

下面的输出结果是什么（）

public class Demo {
  public static void main(String args[])
  {
    String str=new String("hello");
    if(str=="hello")
    {
      System.out.println("true");
    }      
    else     {
      System.out.println("false");
    }
  }
}
//false

如果一个类引用了某个接口，就必须在类中重写接口中定义的所有抽象方法
接口声明的关键字是 interface
在使用interface声明一个接口的时，只可以使用 public修饰符修饰该接口
实现一个接口必须实现接口的所有方法
在java中，能够实现多重继承的技术是 接口
一个类如果实现一个接口，那么它需要实现接口中定义的全部抽象方法，否则该类就被定义为 抽象类
switch语句判断条件可以接受的数据类型有 int、byte、char、short
一个类可以实现多个接口，接口可以实现 多重继承
一个具体类实现接口时，需要重写接口中的成员方法
public、static、final可以修饰接口中的成员变量
final修饰符不可以修饰接口、可以修 类、方法、变量

下列程序的运行结果是（）

public class Test{
    public static void main(String[] args){
        int x=3,y=4,z=5;
        if(x>3){
            if(y<2)
                System.out.println("show one");
            else
                System.out.println("show two");
        }
        else{
            if(z>4)
                System.out.println("show three");
            else
                System.out.println("show four");
        }
    }
}
//show three

下列程序的运行结果是（）

public class MyCase{
      public static void main(String[] args){
         char c='a';
         switch(c){
           case 'a':System.out.print(c);
           case 'b':System.out.print('b');
           case 'c':System.out.print('c');
         }
     }
}
//abc

下列概念中不包括任何实现，与存储空间没有任何关系的是接口
下列有关switch的叙述中，正确的是 case子句中的值必须是常量

x的取值在（）范围内时将打印字符串 ”second“

if(x>0)
    System.out.println("first"); 
else if(x>-3) 
    System.out.println("second"); 
else 
    System.out.println("third"); 
//x<=0&&x>-3

下列关于for循环和while循环的说法中 while循环能实现的操作，for循环也都能够实现是正确的
下列可用switch(expression)语句参数的是 int i

如果要输出Test 2，那么条件是（）

if(x>4){
    System.out.println("Test 1");
}else if(x>9){
    System.out.println("Test 2");
}else{
    System.out.println("Test 3");
}
//没有正确答案

接口中，除了抽象方法之外，还可以含有 常量
在使用interface声明一个接口时，用下面 public 修饰符修饰该接口时，该接口被使用的范围最广。

下列m的哪个值将引起"default"的输出（）

public class Test1{
    public static void main(String args[]){
         int m=Integer.parseInt(args[0]);
         switch(m)
         {
              case 0:System.out.println("case 0");
              case 1:System.out.println("case 1");
              case 2:System.out.println("case 2");break;
              default:System.out.println("default");
         }
    }
}
//3

在java中，能实现多重继承效果的方式是 接口
在java中，除了抽象方法还可以含有 常量

若打印字符串"How are you?"，则x 的取值范围是（）

if(x>0)
    System.out.println("Hello.");
else if(x>-3)
    System.out.println("Nice to meet you!");
else
    System.out.println("How are you?");
//x<=-3

switch语句中表达式(expression)的值不允许用的类型是 boolean
接口可以被继承
do while循环至少一次运行你的代码

阅读下面代码，输出 hello （）次。

public class Program
  {
    public static void main(String args[])
     {
        int x = 0;
        int y = 5;
        while (x < y) {
          System.out.println("Hello");
          x++;	
        }
     }
  }
//5

下列语句序列执行后，k的值是

int i=10, j=18, k=30;
switch( j - i )
{ 	case 8 : k++;
	case 9 : k+=2;
	case 10: k+=3;
	default : k/=j;
}
//2

下列语句序列执行后，j 的值是（）

int j=9, i=6;
while( i-- >3 )
    --j;
//6

能构成多分支的语句是 switch语句

下列语句序列执行后，k 的值是（）

int m=3, n=6, k=0;
while( (m++) < ( -- n) ) 
    ++k;
//1

下列语句序列执行后，k 的值是

int i=6, j=8, k=10, n=5, m=7;
if( i<j || m<n ) k++; else k–;
//11

下列语句序列执行后，i 的值是

int i=8, j=16;
if( i-1 > j ) i–; else j–;
//8

java语言是面向对象的语言
封装是面向对象设计方法的主要特征
面向对象的最重要的特性是支持继承、封装、多态
面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
对于同一类中的两个方法 , 在判断它们是不是重载方法时 , 肯定不考虑返回值类型，考虑参数个数、参数类型、参数顺序
Java语言中，方法的重写（Overriding）和重载（Overloading）是多态性的不同表现。
重写是父类与子类之间多态性的一种表现
成员内部类是外部类的一个成员，可以访问外部类的其他成员
外部类可以访问成员内部类的成员
方法内部类只能在其定义的当前方法中进行实例化
静态内部类中可以定义静态成员，也可以定义非静态成员
在一个类中，除了可以定义属性、方法，还可以定义类，这样的类被称为 内部类
数据由高类型转换到低类型时,采用强制转换,数据精度要受到损失
如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象。
在一个类中可以定义多个名称相同，但参数不同的方法，这叫做方法的 重载
面向对象是指以对象为中心，分析、设计和实现应用程序的机制
Java程序默认引用的包是 java.lang包
十进制数16的16进制表示格式是0x10
内部类可直接访问定义它的外部类的变量
Java中的接口支持多继承
实现了对象信息隐藏的机制是封装
Java语言有自动收集垃圾的功能，垃圾回收调用的方法是 finalize()
Java平台有三种：Java SE，Java ME和Java EE
若某个Java程序的主类是MyClock，那么该程序的源文件名应该是 MyClock.java
可以获得构件前景色的方法是 getForeground()
在switch(expression)语句中，expression的数据类型不能是 double
在Java中，用package语句说明一个包时，该包的层次结构必须是 与文件目录的层次相同
可以作为无限循环语句的是 for(;;){ }
对鼠标点击按钮操作进行事件处理的接口是 MouseListener
在JDK目录中，Java程序运行环境的根目录是 jre
"++"运算符的操作数个数是 1个
在Java中，所有类的根类是 java.lang.Object
按运算符操作数的数目划分，运算符?:的类型是 三元
能够运行java字节码的命令是 java
不能将boolean类型的数值转换为其他基本数据类型
在执行Java程序时，将应用程序连接到调试器的选项是 -debug
在编译Java程序时，用于指定生成.class文件位置的选项是 -d
在Java语言中，不允许使用指针体现出的Java特性是 安全性
在Java中，实现用户界面功能的包是 java.awt
在Java中，由Java编译器自动导入，而无需在程序中用import导入的包是 java.lang
匿名内部类可以有构造方法

使用final关键字修饰Animal类后，程序的输出结果是（）

final class Animal {
	public Animal() {
		System.out.println("我是一只动物");
	}
}
class Dog extends Animal {
	public Dog() {
	}
}
public class Test {
	public static void main(String[] args) {
		Dog dog = new Dog(); // 创建Dog类的实例对象
	}
}
//编译错误

以下代码的循环次数是（）

public class Test {
	public static void main(String args[]) {
		int i = 7;
		do {
			System.out.println(--i);
			--i;
		} while (i != 0);
			System.out.println(i);
		}
        
    }
}
//无限次

说明输出结果

package test; 
import java.util.Date;  
public class SuperTest extends Date{  
    private static final long serialVersionUID = 1L;  
    private void test(){  
       System.out.println(super.getClass().getName());  
    }  
     
    public static void main(String[]args){  
       new SuperTest().test();  
    }  
}  
//test.SuperTest

下面这段java代码，当 T 分别是引用类型和值类型的时候，分别产生了多少个T对象和T类型的值（）
```
T t = new T();(值类型时:T t;)
Func(t);
Func 定义如下：
public void Func(T t) {  }
//1 2
```
实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。
类变量指的是用 static 修饰的属性
final 变量指的是用 final 修饰的变量
单例模式中，两个基本要点是 构造函数私有、唯一实例
对于语句NSString*obj = [[NSData alloc] init]; obj在编译时和运行时分别时什么类型的对象？编译时是NSString的类型；运行时是NSData类型的对象
只有实现了 Serializable 接口的类，其对象才能序列化
Java中常用的循环结构有 for、do-while、while 3种。
Java中常用的循环结构有（1）、（2）和（3）3种。

下列循环语句的循环次数是（）

int i = 5;
do {
    System.out.println(i--);
    i--;
} while(i!=0);
//无限

所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用 private关键字来私有化
在java中，提供一个 javadoc命令，用于将程序中的文档注释提取出来，生成HTML格式的帮助文档
在java中，可以使用关键字 new来创建类的实例对象
被final修饰的成员变量为常量
当一个类的方法被final关键字修饰后，这个类的子类将不能重写该方法
私有属性只能在它所在类中被访问，为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法。
封装就是隐藏对象的属性和实现细节，仅对外提供公有的方法。

请阅读下面的程序片段

int x = 1, y = 1;
if (x++ == 2 & ++y == 2) {
    x = 7;
}
System.out.println("x=" + x + " , y=" + y);
//x=2,y=2

执行后的输出是

public class Test
{
    public static void main(String arg[]){
        int i = 5;
        do{
              System.out.println(i);
          }while (--i>4);
    }
}
//5

程序运行期间帮助加载新类的类是 Class
abstract类只能用来派生子类，不能用来创建abstract类的对象
abstract不能与final同时修饰一个类
abstract方法必须在抽象类中声明，但abstract类定义中可以没有抽象方法
子类继承父类的非私有属性和方法
下列包中，包含JOptionPane类的是 javax.swing
Java是 Sun 公司提出来的。
下列 \\ 是反斜杠字符的正确表示。

下列______是反斜杠字符的正确表示。

int  x=3；
int  y=10；
System.out.println(y%x);
//1

在成员方法的访问控制修饰符中，规定访问权限包含该类自身、同包的其他类和其他包的该类子类的修饰符是 protected
在成员变量的修饰符中，规定只允许该类自身访问的修饰符是 private
在类的修饰符中，规定只能被同一包类所使用的修饰符是 默认

i的最终结果是

int  i, sum=0;
for(i=0;i<10;++i,sum+=i); 
//10

Java中关系表达式的值可能是 true或 false
在Java语言中，被称为内存分配的运算符是 new
在静态方法中调用本类的静态方法时可直接调用
如果子类要调用父类的构造函数，则通过 super 调用来实现。
不考虑反射机制，一个子类显式调用父类的构造器必须用super关键字。
在Java中类只允许单一继承
如果一个方法或变量是private 访问级别，那么它的访问范围是在当前类中
java的单一继承使代码更可靠
类 B 从类 A 派生，则类 B 可以访问类 A 中的 public 成员
静态成员变量（或称类变量）是通过 类名 来访问的。
类中定义一个无参的构造方法，并且声明为私有
在内部类创建一个该类的实例对象，使用静态变量引用该实例对象
使用private修饰静态变量，禁止外界直接访问
定义静态方法返回该类实例
成员变量、成员方法、成员内部类可以使用static关键字修饰
类中static修饰的变量或方法，可以使用类名或对象的引用变量访问。
被 static 关键字修饰的成员变量被称为静态变量，它可以被该类的所有实例对象共享
在非静态成员方法中，可以使用关键字 this访问类的其他非静态成员
静态方法可以被类名调用，也可以被对象调用
静态方法属于类的共享成员
静态方法是通过"类名.方法名"的方式来调用
静态方法中可以访问静态变量
静态变量可以被类直接调用，因此可以说静态变量的生命周期与实例无关
静态方法只能处理静态变量或调用静态方法
静态初始化器是用来对类进行初始化的，而不是对某个对象初始化
静态初始化器是由关键字static和一对花括号组成的语句组
静态初始化器不同于构造方法，它不是方法
在类体内说明静态方法使用关键字static
静态方法不占用对象的内存空间，非静态方法占用对象的内存空间
装箱、拆箱操作发生在引用类型与值类型之间
根据作用域规则，在函数中定义的变量只能在函数中引用
在函数中定义的变量不能与其所在函数的形参同名
在函数中定义的变量，其存储单元在内存的栈区

下面代码的运行结果是（）

public static void main(String[] args){
    String s;
    System.out.println("s="+s);
}
//由于String s没有初始化，代码不能编译通过。

运行时常量池大小受栈区大小的影响
当父类的成员被屏蔽时，如果要引用父类中的成员变量或成员方法，就必须使用 super 来引用。
Java规定，如果子类中定义的成员方法与父类中定义的成员方法同名，并且参数的个数和类型以及 返回值 的类型也相同，则父类中的同名成员方法被屏蔽。
Java规定，当局部变量与成员变量的同名时，局部变量会 覆盖 成员变量。
子类覆盖父类的方法时，子类的方法声明必须与其父类中的声明完全一样
子类将继承父类的非私有属性和方法
super关键字可以调用父类的构造方法
super关键字可以调用父类的普通方法
super()与this()不能同时存在于同一个构造方法中
Java中被final关键字修饰的变量，不能被重新赋值。
在Java语言中，所有的类都直接或间接继承自 Object 类。
如果子类想使用父类中的成员，可以通过关键字 super引用父类中的成员
定义一个java类时，如果前面使用 final关键字修饰，那么该类不可以被继承
在java语言中，允许使用已存在的类作为创建新的类，这种技术称为 继承
定义在类中的变量称为 成员变量，定义在方法中的变量称为 局部变量
子类可以继承父类的共有的属性和方法
super关键字是在子类对象内部指代其父类对象的引用
子类和父类对象在进行类型转换时，子类对象可以被视为父类的一个对象，父类对象不能被当作是某一个子类的对象。
Java的字符类型采用的是Unicode编码方案，每个Unicode码占用 16 个比特位。
源文件名与public类型的类名必须相同
Java中所有类的父类是 Object对象
下列有关 java 构造函数叙述正确的是 构造器可以有0个，1个或一个以上的参数
为初始化其成员变量，每个类都定义的方法是 构造方法
使用this调用构造方法的格式为this([参数1，参数2…]}
只能在构造方法中使用this调用其他的构造方法
使用this调用其他构造方法的语句必须放在第一行
不能在一个类的两个构造方法中使用this互相调用
构造方法：方法名必须和类名相同；方法名的前面没有返回值类型的声明；在方法中不能使用return语句返回一个值；构造方法可以重载
创建对象时，构造方法会被调用
java中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的构造方法
java中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的构造方法
super调用父类构造方法的代码必须位于子类构造方法的第一行。
构造方法是类的一个特殊成员，它会在类实例化对象时被自动调用。
多行注释的作用是为了使代码易于阅读。
构造方法在创建对象的时候被调用
一个类中可以定义多个构造方法
如果在一个类中定义有参的构造方法,jvm就不会提供默认的无参构造方法
构造方法的作用是用来给属性进行初始化的
Java程序运行时，必须经过编译和运行两个步骤。
创建对象时系统将调用适当的构造方法给对象初始化。
Java 语言具有良好的安全性和可移植性及平台无关性
构造方法名必须与类名相同，它没有返回值，用户不能直接调用它，只能通过new调用。
JAVA语言中属于跳转语句的是 break
下列特点中不属于Java的是 多继承
构造方法在创建对象的时候被调用
接口方法的访问权限默认都是public
java中提供了 通过子类对父类方法的覆盖实现多态、利用重载来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
多态的作用是 提高可重用性、扩展代码模块
抽象类不能被实例化
一个抽象类不需要其中所有的方法都是抽象的
多态的表现形式有重写
若要实现一个接口为普通类则必须实现接口的所有抽象方法
若在某一个类定义中定义有如下的方法：abstract void performDial(); 该方法属于 抽象方法
ava中只有整型才能使用的运算符为 %
如果声明一个类时使用abstract修饰符，则表明该类是 抽象类，必须被继承后才能使用
对于abstract类，不能使用new运算符创建该类的对象。
抽象方法只有方法头，而无方法体。
抽象方法是一种只有说明而无具体实现的方法
如果一个类继承了一个抽象类，但是没有完全复写父类的所有的抽象方法那么这个类也必须是抽象类。
父类的引用指向自己子类的对象是多态的一种体现形式。
抽象类实现接口时，可以不实现接口中的任何方法。
三元运算符第一个表达式的结果必须是boolean类型值。

文章来源:https://blog.csdn.net/weixin_51799303/article/details/134980170
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！