1.下列说法正确的是(B
)
A、在类方法中可用this来调用本类的类方法
B、在类方法中调用本类的类方法时可直接调用
C、在类方法中只能调用本类中的类方法
D、在类方法中绝对不能调用实例方法
A,this是个局部变量,静态类方法中不存在,也没办法调用
答案是:
A、在类方法中可用this来调用本类的类方法:错误。在类方法中,this关键字指向当前对象的引用,而类方法是与对象无关的,只能通过类名直接调用类方法。
B、在类方法中调用本类的类方法时可直接调用:正确。在类方法中可以直接调用本类的其他类方法,不需要通过对象引用。
C、在类方法中只能调用本类中的类方法:不完全正确。在类方法中可以调用本类中的其他类方法,也可以调用其他类的类方法,只要通过类名来调用即可。
D、在类方法中绝对不能调用实例方法:不完全正确。在类方法中不能直接调用实例方法,因为实例方法需要通过对象引用来调用。但是,如果在类方法中创建了对象,可以使用该对象来调用实例方法。
2.下面关于 new 关键字的表述错误的是(D
)
A、new关键字在生成一个对象时会为对象开辟内存空间
B、new关键字在生成一个对象时会调用类的构造方法
C、new关键字在生成一个对象时会将生成的对象的地址返回
D、Java中只能通过new关键字来生成一个对象
判断和解析如下:
A、new关键字在生成一个对象时会为对象开辟内存空间:正确。使用new关键字可以在堆内存中为对象分配内存空间。
B、new关键字在生成一个对象时会调用类的构造方法:正确。使用new关键字创建对象时,会调用该类的构造方法来初始化对象。
C、new关键字在生成一个对象时会将生成的对象的地址返回:正确。new关键字返回的是新创建对象的引用(地址)。
D、Java中只能通过new关键字来生成一个对象:错误。除了使用new关键字创建对象外,Java还提供了其他方式来创建对象,如反射、克隆等。因此,这个选项是错误的。
3.将下列(A、B、C、D)哪个代码替换下列程序中的【代码】不会导致编译错误?(A
)
interface Com{
int M=200;
int f();
}
class ImpCom implements Com{
【代码】
}
A、public int f(){return 100+M;}
B、int f(){return 100;}
C、public double f(){return 2.6;}
D、public abstract int f();
正确答案是 A、public int f(){return 100+M;}。
解析:
根据接口Com的定义,它包含一个常量M和一个抽象方法f()。在ImpCom类中,我们需要实现接口Com的抽象方法f()。
选项A中的代码可以正确地实现接口的要求。它定义了一个公共的整型方法f(),并返回100加上接口中定义的常量M的值。
选项B中的代码,接口内默认public int f(),B中缩小了访问修饰符
选项C中的代码返回一个双精度浮点数,与接口中定义的方法返回类型不匹配,因此不符合要求。
选项D中的代码是一个抽象方法的声明,没有提供具体的实现,因此也不符合要求。
因此,选项A是正确的选择,可以替换【代码】部分而不会导致编译错误。
1.以下关于继承的叙述正确的是(A
)
A、在Java中类只允许单一继承
B、在Java中一个类不能同时继承一个类和实现一个接口
C、在Java中接口只允许单一继承
D、在Java中一个类只能实现一个接口
判断和解析如下:
A、在Java中类只允许单一继承:正确。在Java中,一个类只能直接继承自一个父类,即Java不支持多重继承。
B、在Java中一个类不能同时继承一个类和实现一个接口:错误。在Java中,一个类可以同时继承一个类(单一继承)和实现多个接口(多重实现)。
C、在Java中接口只允许单一继承:错误。在Java中,一个接口可以多继承
D、在Java中一个类只能实现一个接口:错误。在Java中,一个类可以实现多个接口,通过逗号分隔多个接口的名称来实现多重接口。这种特性称为多重实现。
综上所述,选项A和C是正确的,选项B和D是错误的。
2.如果Child extends Parent,那么正确的有(BC
)?
A、如果Child是class,且只有一个有参数的构造函数,那么必然会调用Parent中相同参数的构造函数
B、如果Child是interface,那么Parent必然是interface
C、如果Child是interface,那么Child可以同时extends Parent1,Parent2等多个interface
D、如果Child是class,并且没有显示声明任何构造函数,那么此时仍然会调用Parent的构造函数
A,可以调无参
D中,如果父类的私有构造函数,也会调用,不过调不到
3.在java中重写方法应遵循规则的包括(BC
)
A、访问修饰符的限制一定要大于被重写方法的访问修饰符
B、可以有不同的访问修饰符
C、参数列表必须完全与被重写的方法相同
D、必须具有不同的参数列表
A.大于等于,
D:错误,重写不能变
4.下列选项中,用于在定义子类时声明父类名的关键字是:(C
)
A、interface
B、package
C、extends
D、class
略
5.已知如下类定义:
class Base {
public Base (){
//...
}
public Base ( int m ){
//...
}
public void fun( int n ){
//...
}
}
public class Child extends Base{
// member methods
}
如下哪句可以正确地加入子类中?(D
)
A、private void fun( int n ){ //…}
B、void fun ( int n ){ //… }
C、protected void fun ( int n ) { //… }
D、public void fun ( int n ) { //… }
子类重写方法访问修饰符要大于等于父类的访问修饰符
6.在面向对象编程里,经常使用is-a来说明对象之间的继承关系,下列对象中不具备继承关系的是(D
)
A、手机与小米手机
B、企业家与雷军
C、编程语言与Java
D、中国与北京
1.类方法中可以直接调用对象变量。(B
)
A、正确
B、错误
1.要导入java/awt/event下面的所有类,叙述正确的是?(A
)
A、import java.awt.* 和import java.awt.event.* 都可以
B、只能是import java.awt.*
C、只能是import java.awt.event.*
D、import java.awt.* 和import java.awt.event.* 都不可以
1.下列表述错误的是?(D
)
A、int是基本类型,直接存数值,Integer是对象,用一个引用指向这个对象。
B、在子类构造方法中使用super()显示调用父类的构造方法,super()必须写在子类构造方法的第一行,否则编译不通过。
C、封装的主要作用在于对外隐藏内部实现细节,可以增强程序的安全性。
D、final是java中的修饰符,可以修饰类、接口、抽象类、方法和属性。
1.一个类可以有多个不同名的构造函数 (不考虑内部类的情况( B
)
A、正确
B、错误
2.尝试编译以下程序会产生怎么样的结果?()
public class MyClass {
long var;
public void MyClass(long param) {
var = param;
} //(1)
public static void main(String[] args) {
MyClass a, b;
a =new MyClass(); //(2)
b =new MyClass(5); //(3)//没有单参的构造函数
}
}
没有构造器,默认无参,b输入5编译报错
面向对象方法的多态性是指(C
)
A、一个类可以派生出多个特殊类
B、一个对象在不同的运行环境中可以有不同的变体
C、针对一消息,不同的对象可以以适合自身的方式加以响应
D、一个对象可以是由多个其他对象组合而成的
A.继承
B。
1.阅读如下代码。 请问,对语句行 test.hello(). 描述正确的有(A
)
package NowCoder;
class Test {
public static void hello() {
System.out.println("hello");
}
}
public class MyApplication {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test test=null;
test.hello();
}
}
A、能编译通过,并正确运行
B、因为使用了未初始化的变量,所以不能编译通过
C、以错误的方式访问了静态方法
D、能编译通过,但因变量为null,不能正常运行
2.关于以下程序代码的说明正确的(D
)
class HasStatic{
private static int x = 100;
public static void main(String args[ ]){
HasStatic hs1 = new HasStatic();
hs1.x++; //101
HasStatic hs2 = new HasStatic();
hs2.x++; //102
hs1=new HasStatic();
hs1.x++;//103
HasStatic.x--; //102
System.out.println( "x=" +x);
}
}
A、5行不能通过编译,因为引用了私有静态变量
B、10行不能通过编译,因为x是私有静态变量
C、程序通过编译,输出结果为:x=103
D、程序通过编译,输出结果为:x=102
3.关于static说法不正确的是(D
)
A、可以直接用类名来访问类中静态方法(public权限)
B、静态块仅在类加载时执行一次
C、static方法中不能有用this调用的方法
D、不可以用对象名来访问类中的静态方法(public权限)
可以
4.为AB类的一个无形式参数无返回值的方法method书写方法头,可以用AB.method()方式调用,该方法头的形式为(A
)。
A、static void method( )
B、public void method( )
C、final void method( )
D、abstract void method( )
5.下面代码的运行结果是(C
)
public class Arraytest{
int a[] = new int[6];
public static void main ( String arg[] ) {
System.out.println ( a[0] );
}
}
A、null
B、0
C、编译出错
D、运行出错
静态不能访问非静态
6.下面关于静态方法说明正确的是(B
)
A、在静态方法中可用this来调用本类的类方法
B、在静态方法中调用本类的静态方法时可直接调用
C、在静态方法中只能调用本类中的静态方法
D、在静态方法中绝对不能调用实例方法
7.关于以下代码的说明,正确的是(C
)
1. class StaticStuff
2. {
3. static int x=10;
4. static { x+=5;}
5. public static void main(String args[ ])
6. {
7. System.out.println(“x=” + x);
8. }
9. static { x/=3;}
10. }
A、4行与9行不能通过编译,因为缺少方法名和返回类型
B、9行不能通过编译,因为只能有一个静态初始化器
C、编译通过,执行结果为:x=5
D、编译通过,执行结果为:x=3
8.When is the text “Hi there” displayed?(C
)
public class StaticTest
{
static
{
System.out.println("Hi there");
}
public void print()
{
System.out.println("Hello");
}
public static void main(String args[])
{
StaticTest st1 = new StaticTest();
st1.print();
StaticTest st2 = new StaticTest();
st2.print();
}
}
A、Never.
B、Each time a new object of type StaticTest is created.
C、Once when the class is loaded into the Java virtual machine.
D、Only when the main() method is executed.
9.子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块 执行的先后顺序是?(C
)
A、父类B静态代码块->父类B构造函数->子类A静态代码块->父类B非静态代码块->子类A构造函数->子类A非静态代码块
B、父类B静态代码块->父类B构造函数->父类B非静态代码块->子类A静态代码块->子类A构造函数->子类A非静态代码块
C、父类B静态代码块->子类A静态代码块->父类B非静态代码块->父类B构造函数->子类A非静态代码块->子类A构造函数
D、父类B构造函数->父类B静态代码块->父类B非静态代码块->子类A静态代码块->子类A构造函数->子类A非静态代码块
1.程序Demo.java编译运行后输出的结果是:(A
)
public class Demo{
int x=1;
int y;
public static void main(String [] args){
int z=2;
Demo t=new Demo();
System.out.println(t.x+t.y+z);
}
}
A、3
B、12
C、1
D、5
2.关于如下程序的描述哪个是正确的?( C
)
public class Person{
static int arr[] = new int[5];
public static void main(String a[]){
System.out.println(arr[0]);
}
}
A、编译将产生错误
B、编译时正确,但运行时将产生错误
C、正确,输出0
D、正确,输出 null
1.protected访问权限要小于包访问权限。(B
)
A、正确
B、错误
2.在java中,下列说法正确的是(D
)
A、一个类可以继承多个父类
B、修饰符可维protected的属性不能被其子类访问
C、抽象类可以实例化对象
D、无public修饰的类,不能被非同一文件夹中的类和非同一包中的类访问
同一文件夹:物理结构下的文件夹(文件路径不同) mkdir -p com/briup/day1.....
2.要使某个类能被同一个包中的其他类访问,但不能被这个包以外的类访问,可以( A
)
A、让该类不使用任何关键字
B、使用private关键字
C、使用protected关键字
D、使用void关键字
1.下列描述正确的是(A C
)?
A、类不可以多继承而接口可以多实现
B、抽象类自身可以定义成员而接口不可以
C、抽象类和接口都不能被实例化
D、一个类可以有多个基类和多个基接口
2.对于abstract声明的类,下面说法正确的是(E
)
A、可以实例化
B、不可以被继承
C、子类为abstract
D、只能被继承
E、可以被抽象类继承
3.有以下类定义:(B
)
abstract class Animal{
abstract void say();
}
public class Cat extends Animal{
public Cat(){
System.out.printf("I am a cat");
}
public static void main(String[] args) {
Cat cat=new Cat();
}
}
A、I am a cat
B、Animal能编译,Cat不能编译
C、Animal不能编译,Cat能编译
D、编译能通过,但是没有输出结果
1.以下关于java封装的描述中,正确的是:A
A、封装的主要作用在于对外隐藏内部实现细节,增强程序的安全性
B、封装的意义不大,因此在编码中尽量不要使用
C、如果子类继承父类,对于父类中进行封装的方法,子类仍然可以直接调用
D、只能对一个类中的方法进行封装,不能对属性进行封装
1.内部类(也叫成员内部类)可以有4种访问权限。( A
)
A、正确
B、错误
填空题
一、填空题
1.类是组成Java程序的基本要素,类体有两部分构成:一部分是___变量
__ 的定义,另一部分是 方法
__ 的定义。
2.执行Person p = new Person();语句后,将在 _____ 堆
__ 内存 中给Person对象分配空间,并在 栈
__内存中给引用变量p分配空间,存放Person对象的引用。
3.__ _____ 构造方法
____ 是一种特殊方法,它的名字必须与它所在的类的名字完全相同,并且不书写返回值类型,在创建对象实例时由new运算符自动调用。
4.局部变量的名字与成员变量的名字相同,若想在该方法内使用成员变量,必须使用关键字 _____ this
__ 。
5.使用关键字 _ _____ _this
_ __来调用同类的其它构造方法,优点同样是以最大限度地代码的利用程度 ,减少程序的维护工作量。
6.用关键字_ _____ static
__修饰的成员变量是类变量,类变量是指不管类创建了多少对象,系统仅在第一次调用类的时候为类变量分配内存,所有对象共享该类的类变量。
7.使用static修饰的变量称为静态变量,静态变量可以有两种访问方式,分别是_____ 通过类名访问__ 和
_____ 通过对象访问 __。
8.在一个类文件中的关键字package,import,class出现的可能顺序是 _____ 1>2>3
__。
9 _____ _package_
__关键字作为Java源文件的第一条非注释性语句,指明该源文件定义的类所有的包。
10 _____ _java.lang
_ __ 包是Java语言的核心类库,它包含了运行Java程序必不可少的系统类,使用该包下的类和接口不需要使用import导入。
二、选择题
在Java中,以下程序编译运行后的输出结果为( D
)。(选择一项)
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}
A 6
B. 34
C. 8
D. 7
分析如下Java程序的代码所示,则编译运行后的输出结果是( C
)。(选择一项)
public class Test {
int count=9;
public void count1(){
count=10;
System.out.println("count1="+count);
}
public void count2(){
System.out.println("count2="+count);
}
public static void main(String[ ] args) {
Test t=new Test();
t.count1();
t.count2();
}
}
A
count1=9;
count2=9;
B.
count1=10;
count2=9;
C.
count1=10;
count2=10;
D.
count1=9;
count2=10;
3.以下语句中关于Java构造方法的说法错误的是( B
)。(选择一项)
A. 构造方法的作用是为创建对象进行初始化工作,比如给成员变量赋值
B. 一个Java类可以没有构造方法,也可以提供1个或多个构造方法
C. 构造方法与类同名,不能书写返回值类型
D. 构造方法的第一条语句如果是super(),则可以省略,该语句作用是调用父类无参数的构造方法
4.在Java中关于静态方法,以下说法中正确的是(ABC
)。(选择两项)
A 静态方法中不能直接调用非静态方法
B. 非静态方法中不能直接调用静态方法(递归)
C. 静态方法可以用类名直接调用
D. 静态方法里可以使用this
5.下列选项中关于Java中类方法的说法错误的是(AC
)。(选择二项)
A 在类方法中可用this来调用本类的类方法
B. 在类方法中调用本类的类方法时可直接调用
C. 在类方法中只能调用本类中的类方法
D. 在类方法中调用实例方法需要先创建对象
判断题
1.类可以看成一类对象的模板,对象可以看成该类的一个具体实例。(true
)
2.如果没有为类中的某些成员赋初始值,Java会为类成员赋予固定的初始值,如数值变量的值为0,布尔变量的值为true,未初始化的引用为null。( false
)
3.Java中所有的变量,不管是成员变量还是局部变量,在使用前都必须进行初始化。(false
)
4.在Java中对象可以赋值,只要使用赋值运算符即可,相当于生成了一个各属性与赋值对象相同的新对象。(false
)
5.System.out.println(“Hello java!”)中out是System类的一个静态成员变量。(true
)
6.构造方法用于创建对象,一般不允许有任何返回值,因此需要在构造方法返回类型处标注为void。(false
)
7.Java语言为所有的Java程序自动导入包“java.lang”,因此Java程序可以直接用“java.lang”中的类和接口。(true
)
四、简答题
1.四种访问修饰符以及区别
- public 所有
- protected 子类
- default 本包
- private 本类
2.this和super的区别
- this调用本类
- super调用父类
3.什么情况会构成方法重载 ,什么情况不构成方法重载
- 方法名一致,参数值个数不一致,数据类型不一致会构成重载
4.什么情况会造成方法重写,什么方法不能重写
- 方法名一致,参数个数一致,数据类型一致,参数顺序一致会构成重写
5.final的作用
- 不允许重写,将变量变为常量,不允许实现
6.abstract的作用
- 将类或者方法变为抽象类或者抽象方法
7.成员变量和局部变量的区别
- 局部变量只能在方法内使用,成员变量可以在整个类中使用
8.抽象类和非抽象类的区别
- 抽象类只能让子类去实现,不能被实例化
- 非抽象类不能编写抽象方法
9.一个类中,是否总会存放默认的无参构造器?
- 是的
10.static成员变量和非静态成员变量的区别
程序分析题
分析以下代码是否能通过编译
public class A{
protected int test(){
return 0;
}
}
class B extends A{
public long test(){
return 0L;
}
}
// 编译错误
2.分析以程序的结果
package work.day7;
public class Test {
public Test() {
System.out.println("构造器");
}
public void info() {
System.out.println("info");
}
static {
System.out.println("test static 1");
}
public static void main(String[] args) {
new Test().info();
}
static {
System.out.println("test static 2");
}
}
//test static 1
//test static 2
//构造器
//info
3.分析以下程序结果
package work.day7;
public class Test {
public static void main(String[] args) {
Zi z = new Zi();
}
}
class Fu {
static {
System.out.println("静态代码块Fu");
}
{
System.out.println("构造代码块Fu");
}
public Fu() {
System.out.println("构造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块Zi");
}
{
System.out.println("构造代码块Zi");
}
public Zi() {
System.out.println("构造方法Zi");
}
}
//静态代码块Fu
//静态代码块zi
//构造代码块付
//构造方法zi....
3.分析以下程序结果
package work.day7;
public class B {
public static B t1 = new B();
public static B t2 = new B();
{
System.out.println("构造块");
}
static {
System.out.println("静态块");
}
public static void main(String[] args) {
B t = new B();
}
}
/*
构造块
构造块
静态块
构造块
*/
4.分析以下程序结果
public class FinalMethodTest {
public static void main(String[] args) {
FinalMethodTest test = new Sub();
test.test();
}
private final void test() {
System.out.println("父类");
}
}
class Sub extends FinalMethodTest {
public void test() {
System.out.println("子类");
}
}
// 父类
其他选择题
下面的方法,当输入为2的时候返回值是多少? D
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; }
A. 0
B. 2
C.4
D.10
设三个整型变量 x = 1 , y = 2 , z = 3,则表达式 y+=z--/++x 的值是( A)。
A.3
B.3.5
C.4
D.5
以下代码的循环次数是 D
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);
}
}
A 0
B 1
C 7
D 无限次
以下程序的执行结果是: A
static boolean foo(char c) {
System.out.print(c);
return true;
}
public static void main(String[] args) {
int i =0;
for(foo('A');foo('B')&&(i<2);foo('C')) {
i++;
foo('D');
}
A. ABDCBDCB
B. ABCDABCD
C. 编译时出错
D. 运行时抛出异常
标签:调用,Java,void,面向对象,static,测试,new,public From: https://www.cnblogs.com/Hlmove/p/17759155.html编程题