一个Java类访问权限的选择题和一个判断题 Posted 2023-05-01
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了一个Java类访问权限的选择题和一个判断题相关的知识,希望对你有一定的参考价值。
关于访问权限说法正确的是? ( D ) A、类定义前面可以修饰public,protected和private B、内部类前面可以修饰public,protected和private C、局部内部类前面可以修饰public,protected和private D、以上说法都不正确 内部类(也叫成员内部类)可以有4种访问权限。(F ) 这个为什么是D?为什么又是F? 我看笔记好像Java类可用default和public修饰,然后内部类是四个权限都可以的啊。这道题答案会不会有问题?还有可以简单说一些局部内部类和一般内部类的区别吗?谢谢! 可不可以针对这两道题简明地说下究竟错在哪里呢?
参考技术A
内部类不能被外界类调用,只能由outer的对象才能调用。所以public肯定是不行的。追问 就是同一个java文件里额。成员内部类的话,我试过了。四种权限都没问题能通过。 就这道题,你说错是错在哪里呢?是太笼统了吗?
参考技术B
public 公共类 default 默认类(即class前什么都不假) abstract 抽象类 fanal 不能被继承的类 static 静态类 private 只能修饰内部类,一般不推荐使用 protected 继承 类的修饰符有这些
参考技术C
Java 内部类 分四种:成员内部类、局部内部类、静态内部类和匿名内部类。 1、成员内部类: 即作为外部类的一个成员存在,与外部类的属性、方法并列。 注意:成员内部类中不能定义静态变量,但可以访问外部类的所有成员。 public class Outer private static int i = 1; private int j=10; private int k=20; public static void outer_f1() //do more something public void out_f2() //do more something //成员内部类 class Inner //static int inner_i =100; //内部类中不允许定义静态变量 int j=100;//内部类中外部类的实例变量可以共存 int inner_i=1; void inner_f1() System.out.println(i);//外部类的变量如果和内部类的变量没有同名的,则可以直接用变量名访问外部类的变量 System.out.println(j);//在内部类中访问内部类自己的变量直接用变量名 System.out.println(this.j);//也可以在内部类中用"this.变量名"来访问内部类变量 //访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"。 System.out.println(k);//外部类的变量如果和内部类的变量没有同名的,则可以直接用变量名访问外部类的变量 outer_f1(); outer_f2(); //外部类的非静态方法访问成员内部类 public void outer_f3() Inner inner = new Inner(); inner.inner_f1(); //外部类的静态方法访问成员内部类,与在外部类外部访问成员内部类一样 public static void outer_f4() //step1 建立外部类对象 Outer out = new Outer(); //***step2 根据外部类对象建立内部类对象*** Inner inner=out.new Inner(); //step3 访问内部类的方法 inner.inner_f1(); public static void main(String[] args) outer_f4(); 成员内部类的优点: ⑴ 内部类作为外部类的成员,可以访问外部类的私有成员或属性。(即使将外部类声明为PRIVATE,但是对于处于其内部的内部类还是可见的。) ⑵ 用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。 注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。 2、局部内部类: 即在方法中定义的内部类,与局部变量类似,在局部内部类前不加修饰符public或private,其范围为定义它的代码块。 注意:局部内部类中不可定义静态变量,可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的。 public class Outer private int s = 100; private int out_i = 1; public void f(final int k) final int s = 200; int i = 1; final int j = 10; class Inner //定义在方法内部 int s = 300;//可以定义与外部类同名的变量 //static int m = 20;//不可以定义静态变量 Inner(int k) inner_f(k); int inner_i = 100; void inner_f(int k) System.out.println(out_i);//如果内部类没有与外部类同名的变量,在内部类中可以直接访问外部类的实例变量 System.out.println(k);//*****可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的***** // System.out.println(i); System.out.println(s);//如果内部类中有与外部类同名的变量,直接用变量名访问的是内部类的变量 System.out.println(this.s);//用"this.变量名" 访问的也是内部类变量 System.out.println(Outer.this.s);//用外部"外部类类名.this.变量名" 访问的是外部类变量 new Inner(k); public static void main(String[] args) //访问局部内部类必须先有外部类对象 Outer out = new Outer(); out.f(3); 注意: 在类外不可直接生成局部内部类(保证局部内部类对外是不可见的)。要想使用局部内部类时需要生成对象,对象调用方法,在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合,用局部内部类来实现接口,并在方法中返回接口类型,使局部内部类不可见,屏蔽实现类的可见性。 3、静态内部类: 静态内部类定义在类中,任何方法外,用static定义。 注意:静态内部类中可以定义静态或者非静态的成员 public class Outer private static int i = 1; private int j = 10; public static void outer_f1() public void outer_f2() // 静态内部类可以用public,protected,private修饰 // 静态内部类中可以定义静态或者非静态的成员 static class Inner static int inner_i = 100; int inner_j = 200; static void inner_f1() System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员 outer_f1();//包括静态变量和静态方法 void inner_f2() // System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员 // outer_f2();//包括非静态变量和非静态方法 public void outer_f3() // 外部类访问内部类的静态成员:内部类.静态成员 System.out.println(Inner.inner_i); Inner.inner_f1(); // 外部类访问内部类的非静态成员:实例化内部类即可 Inner inner = new Inner(); inner.inner_f2(); public static void main(String[] args) new Outer().outer_f3(); 注意:*******生成(new)一个静态内部类不需要外部类成员:这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成: Outer.Inner in=new Outer.Inner(); 而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。静态内部类不可用private来进行定义。******* 例子: 对于两个类,拥有相同的方法: class People run(); class Machine run(); 此时有一个robot类: class Robot extends People implement Machine. 此时run()不可直接实现。 注意:当类与接口(或者是接口与接口)发生方法命名冲突的时候,此时必须使用内部类来实现。用接口不能完全地实现多继承,用接口配合内部类才能实现真正的多继承。 4、匿名内部类 匿名内部类是一种特殊的局部内部类,它是通过匿名类实现接口。 IA被定义为接口。 IA I=new IA(); 匿名内部类的特点: 1,一个类用于继承其他类或是实现接口,并不需要增加额外的方法,只是对继承方法的事先或是覆盖。 2,只是为了获得一个对象实例,不需要知道其实际类型。 3,类名没有意义,也就是不需要使用到。 public class Outer private static int i = 1; private int j = 10; public static void outer_f1() public void outer_f2() // 静态内部类可以用public,protected,private修饰 // 静态内部类中可以定义静态或者非静态的成员 static class Inner static int inner_i = 100; int inner_j = 200; static void inner_f1() System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员 outer_f1();//包括静态变量和静态方法 void inner_f2() // System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员 // outer_f2();//包括非静态变量和非静态方法 public void outer_f3() // 外部类访问内部类的静态成员:内部类.静态成员 System.out.println(Inner.inner_i); Inner.inner_f1(); // 外部类访问内部类的非静态成员:实例化内部类即可 Inner inner = new Inner(); inner.inner_f2(); public static void main(String[] args) new Outer().outer_f3(); 注:一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类,没有类名,根据多态,我们使用其父类名。因他是局部内部类,那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口,那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法,所以其使用范围非常的有限。当需要多个对象时使用局部内部类,因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口,那么其运行的类型为实现这个接口的类。 ________________________________________________________________________________ 内部类总结: 1.首先,把内部类作为外部类的一个特殊的成员来看待,因此它有类成员的封闭等级:private ,protected,默认(friendly),public 它有类成员的修饰符: static,final,abstract 2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,因此,它可以访问外部类的一切资源(当然包括private) 外部类访问内部类的成员,先要取得内部类的对象,并且取决于内部类成员的封装等级。 非静态内部类不能包含任何static成员. 3.静态内部类:static inner class,不再包含外部类的this指针,并且在外部类装载时初始化. 静态内部类能包含static或非static成员. 静态内部类只能访问外部类static成员. 外部类访问静态内部类的成员,循一般类法规。对于static成员,用类名.成员即可访问,对于非static成员,只能 用对象.成员进行访问 4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。 类成员有两种static , non-static,同样内部类也有这两种 non-static 内部类的实例,必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用 static 内部类的实例, 直接创建即可,没有对外部类实例的引用。 内部类不管static还是non-static都有对外部类的引用 non-static 内部类不允许有static成员 方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表,所以说方法中的内部类和内部类没什麽区别。但方法中的内部类不能在方法以外访问,方法中不可以有static内部类 匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数 匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递 你看看 你就明白 说的很细内不内类追问 可不可以针对这两道题简明地说下究竟错在哪里呢? 答案没问题吗?谢谢~
追答 答案F 是说成员内部内 类 成员内部类的优点: ⑴ 内部类作为外部类的成员,可以访问外部类的私有成员或属性。(即使将外部类声明为PRIVATE,但是对于处于其内部的内部类还是可见的。) ⑵ 用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
本回答被提问者采纳
必看!100道Java程序员面试题(含答案)!
除了掌握扎实的专业技能之外,你还需要一份《Java程序员面试宝典》才能在万千面试者中杀出重围,成功拿下offer。
答案:内部类是指在一个外部类的内部再定义一个类,内部类对外部类有访问权限,可以访问类中定义的所有变量和方法。
子类是从父类(superclass)中继承的类,子类可以访问父类所有public和protected的字段和方法。
Q2:Java语言中有哪些常见的访问说明符,有什么意义?
答案:Java中的访问说明符是放在类名之前,用于定义访问范围的关键字,常见的访问说明符有以下几类:
Public:公共,能被项目中的任何一个Class、Method、Field访问。
Protected:受保护,能被同类或子类访问,不能从外部访问。
Default:默认,只能被同一个包的Class、Method、Field访问。
答案:静态变量被类的所有实例共用,静态类只能访问类的静态变量,或调用类的静态方法。
答案:封装是面向对象编程中用于在单个单元中组合属性和方法。
封装可以帮助程序员遵循模块化方法进行软件开发,每个对象都有自己的一组方法和变量,并且可以独立于其他对象来执行其功能。另外,封装也有数据隐藏的目的。
Q5:什么是 singleton class(单例类)?并给出其用法的实际例子。
答案:单例类只能有一个实例,必须自己创建自己的唯一实例,必须给所有其他对象提供这一实例。
单例使用场景的最佳实践是由于某些驱动程序限制或由于许可问题的限制只能连接数据库。
答案:循环用于编程中重复执行语句,Java中的循环有三类:
for循环用于执行指定重复次数的语句,当程序员明确知道循环次数可以使用for循环。
当语句满足条件时开始进行重复执行,直到语句不再满足条件退出循环。While循环中在执行语句之前先检查是否满足条件。
Do while 和while循环基本类似,唯一不同的是do while是先执行语句再检查条件,也就是说do while循环至少会执行一次语句。
答案:无限循环是指无条件执行,无限运行。无限循环可以由定义中断语句块来结束。
Q8:continue和break语句有什么区别?
答案:break和continue都是循环中的重要关键词,break语句是结束整个循环过程,continue语句只结束本次循环,而不是终止整个循环的执行。
Q9:Java中的double和float变量有什么区别?
答案:float是单精度浮点数,内存中占用4字节,double是双精度浮点数,内存中占用8字节。
Q10:Java中的Final关键字是什么意思?请举例说明
答案:final是Java中的关键字,有“无法改变”、“终态”的含义,final类不能被继承,没有子类,final类中的方法默认是final的,且不能被子类的方法覆盖,但可以被继承。
final成员变量表示常量,只能被赋值一次,赋值后值不再改变。final不能用于修饰构造方法。
下面的例子中,const_val被声明且赋值为常量100:
Private Final int const_val=100
而当一个方法被声明为final之后,它不能被子类覆盖,而且会比其他方法都快。
答案:三元运算符,也称为条件运算符,根据布尔值来决定将哪个值分配给变量,它被表示为...?...:...
在下面的示例中,如果rank为1,status=Done,否则status=Pending
答案:使用Math.random()可以生成0.1到1.0范围内的随机数字,然后通过数学方法实现生成符合要求的随机数。
Q13:举例说明什么是default switch case?
答案:在switch语句中,如果没有case条件匹配,那么它会就会执行default后面的语句。
在下面的例子中,当score既不是1也不是2时,就会执行default之后的语句。
Q15:Java中的main()方法可以返回任何数据吗?
答案:java中的main()方法不能返回任何数据,它的返回类型始终是void。
Q16:什么是Java Packages?其意义是什么?
答案:为了更好地组织类,Java 提供了包机制,用于区别类名的命名空间。
1、把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。
2、
如同文件夹一样,包也采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。因此,包可以避免名字冲突。
3、包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。
Q17:我们可以声明一个抽象类,但是没有任何抽象方法吗?
答案:是的,我们可以声明一个抽象类,且不包含任何抽象方法,但是一旦一个类中含有一个抽象方法,那么该类必须声明为抽象。
答案:抽象类和接口之间的主要区别在于,抽象类可以拥有任意范围的成员数据,同时也可以拥有自己的非抽象方法,但是接口方式中,它仅能够有静态、不能修改的成员数据,同时它所有的方法都必须是抽象的。
抽象类是对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。
答案:与抽象类相比,接口性能较慢。一个类只能扩展一个抽象类,却能实现许多接口,随着接口在类中的实现,也会给开发人员带来额外负担。
答案:在Java中导入包时,其子包不会被导入,如果有需要,开发者必须单独导入。
开发者需要单独导入它们。
Q21:类中的main方法可以声明为private?
答案:Java中main方法必须是public,如果是private,那么它虽然在编译时不会出错,但是在运行时会出错。
答案:序列化是指把Java对象转换为字节序列的过程,只能将支持 java.io.Serializable 接口的对象写入流中,每个 serializable 对象的类都被编码。
Q24:Java中的try...catch是用于异常处理吗?
答案:try后面往往会跟着catch或finally,try抛出的任何异常都会被捕获在catch中,在代码终止前的要执行的任务放在finally中。
Q25:有没有什么办法在出现异常时跳过finally?
答案:当在try中出现异常时,如果存在catch,会先被catch捕获,否则会执行到finally。异常发生时肯定会执行finally,除非在try的末尾有强制中止代码:System.exit(0);
答案:每次用new来创建对象时,都会调用构造函数。
例如,下例中new创建了两个对象,构造函数也被调用了两次。
答案:是的,一个类可以有多个具有不同参数的构造函数,创建对象的构造函数取决于创建对象时传递的参数。
答案:我们不能覆盖静态方法,静态方法属于一个类而不是单个对象,并且在编译时解析(而不是在运行时)。
Displaying from superclass
答案:String不是Java的原始数据类型,Java中创建一个string时,实际上是创建了Java.Lang.String类的对象,这个对象可以使用String类的所有内置方法。
Q31:下面的示例中,共创建了多少个String对象?
答案:共创建了两个java.Lang.String类的对象。s1和s3是对同一个对象的引用。
Q32:为什么Java中的String被称为Immutable?
答案:Java中,string对象是不可变的,一旦赋值不可更改,如果更改,则会创建一个新对象。
在下面的示例中,str是值为“Value One”的字符串对象:
当分配一个新值时,将创建一个新的String对象,并将引用移动到新对象。:
答案:数组是对相同原始类型的数据进行组合,本质上是静态的,而矢量本质上是动态的,并且可以容纳不同数据类型的数据。
答案:多线程是一个编程概念,可以在单个程序中以并发方式执行多个任务。同一个进程的多个线程堆栈共享,有助于程序的性能改进。
Q35:为什么在ava中使用Runnable Interface?
答案:Runnable接口在Java中用于实现多线程应用程序,Java.Lang.Runnable接口由一个支持多线程的类来实现。
1、通过使用Java.Lang.Runnable Interface,通过Run()方法来启用多线程。
2、编写一个扩展Java.Lang.Thread类的类。
Q37:当数据需要进行大量更改时, String和StringBuffer谁是更好的选择?
答案:StringBuffers本质上是动态的,我们可以改变StringBuffer对象的值,而String是不可变的,每次数据更改都会创建一个新的String对象,增加额外开销,所以在数据更改很多的情况下,StringBuffer是一个更好的选择。
Q38:每个switch语句后使用break的目的是什么?
答案:switch使用break可以在执行完这个语句后中断,如果不使用break,那么它将把所有情况都执行一遍。
答案:Java中,对象不被引用时,垃圾回收就会发生,对象会被自动销毁,调用System.gc()方法或Runtime.gc()方法。
答案:如果我们要在类加载时,对象创建之前执行语句,可以在类中使用静态代码块,这样即使在main方法中创建对象之前,此静态代码块中的语句都将在加载类时执行一次。
Q41:一个类可以同时既是父类也是子类吗?请举例说明?
答案:如果使用了继承层次结构,那么这个类就可能既是一个类的父类也是另一个类的子类,如下例中的大陆类既是世界类的子类,同时也是国家类的父类。
Q42:如果类中没有定义构造函数,那么类的对象将会怎么创建?
答案:即使类没有定义显式构造函数,对象在创建时也会执行隐式构造函数,且该构造函数没有参数。
Q43:在多线程中,如何确保资源不会同时被多个线程使用?
答案:在多线程中,可以通过使用同步的概念来控制对多个线程之间共享的资源的访问。使用synchronized关键字,我们可以确保只有一个线程可以一段时间内使用共享资源。
答案:使用new创建对象时,会自动调用构造函数,对象创建之后,则无法再调用该构造函数。
Q45:两个类classA和classB都在同一个包中,那么classA的私有成员可以被classB的对象访问吗?
答案:类的私有成员在该类的范围之外是不可访问的,即使在同一个包中也不能访问任何其他类。
答案:可以定义重名的方法,但是其参数的数量和类型是不同的,调用哪个方法取决于传递的参数。
例如在下面的类中,我们有两个具有相同名称但不同参数的打印方法。根据参数,将调用适当的参数:
答案:使用克隆,我们可以创建具有对象的实际状态的副本。Clone()是Cloneable interface的方法,因此需要实现Cloneable interface来进行对象拷贝。
答案:使用继承的主要优点是代码的可重用性,因为继承使子类能够重用其父类的代码。多态性(可扩展性)是另一个好处,允许引入新的功能而不影响现有的派生类。
答案:变量和方法的默认访问说明符是protected,即变量和类可用于同一个包中的任何其他类。
答案:栈和队列之间的主要区别在于,栈基于“后进先出(LIFO)”原则,而队列基于FIFO(先进先出)原则。
答案:想要某些变量不被序列化,那么可以在声明时使用关键字transient。例如,下面的变量trans_var是一个临时变量,不能被序列化:
答案:Java提倡“一切皆为对象”,引用数据类型可以实例化为对象,基本数据类型却无法变为对象,针对这一不足,JAVA中设置了包装类,例如,Integer是原始数据类型int的包装类。
答案:程序编译时可以捕获被检查的异常,为了成功编译代码,异常会通过try...catch来处理。
NEW:通过New关键字创建了Thread类(或其子类)的对象
RUNNABLE:这种情况指的是Thread类的对象调用了start()方法,线程处于就绪状态。
RUNNING:线程获得了CPU,处于运行状态。
DEAD:处于RUNNING状态的线程,在执行完run方法之后,就变成了DEAD状态了。
BLOCKED:这种状态指的是处于RUNNING状态的线程,出于某种原因,比如调用了sleep方法、等待用户输入等而让出当前的CPU给其他的线程。
Q58:定义了类的显式构造函数之后,还可以使用默认构造函数吗?
答案:如果没有定义显式构造函数,那么Java将提供一个默认的无参数构造函数,但是如果定义了显式构造函数之后,就不能再调用默认构造函数。
Q59:可以有两个方法,它们方法名和参数都相同,但返回值类型不同?
答案:相同的方法指的是方法名、参数以及返回类型都相同,因此返回类型不同的两个方法是可以并存的。
Q61:在没有执行main()的情况下,成功编译了一个Java类,这一说法正确吗?
答案:正确,虽然Java编译器规定程序的入口点为staticmain,但是没有main()还是能够编译,只是不能运行。
答案:非静态方法归类的对象所有,且具有对象的级别范围,所以如果想要在静态方法中调用非静态方法,首先要创建类的对象,然后使用对象引用,调用这些方法。
Q63:为了运行Java程序,必须设置两个环境变量是什么?
答案:Java不会给变量分配默认值,因此变量没有初始化的情况下,程序会编译失败并给出错误提示。
答案:不可以,Java的构造函数必须与类名相同,如果不同,它将被视作普通函数。
Q67:Round(3.7)和Ceil(3.7)的输出分别是什么?
答案:它们的输出都是4。Round()遵循四舍五入,Ceil()遵循向上舍入。
Q68:Java中可以使用goto来转到特定行吗?
答案:JDK是Java的开发工具包,不是必需的,JRE才是必需的。
答案:Java中,==操作比较的是两个变量的值是否相等,对于引用型变量表示的是两个变量在堆中存储的地址是否相同,即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用,即堆中的内容是否相同
下例中,equals()返回true,而==操作符则返回false:
Q73:Java类中定义方法,可否使用其他语言代码实现,如C语言?
答案:可以,在基于原生开发的情况下,我们可以在Java类中定义公共静态方法,但是不执行,然后用另外一种语言(如C)实现。
答案:Java类中没必要定义析构函数,它有自己的垃圾回收机制,当不再引用对象时,会自动执行。
Q75:Java中变量可以既是局部变量又是静态变量吗?
答案:不能,将局部变量定义为静态变量会导致编译错误。
答案:Interface中的静态方法是没有意义的,静态方法在类中不能被覆盖,而Interface中的方法默认都是抽象的,所以只能在实现Interface的类中实现。
Q77:在实现接口的类中,我们可以更改接口中定义的变量的值吗?
答案:不能,接口中定义的变量大多都默认是public、static和final等不可更改的常量。
Q78:Java中的垃圾回收机制能够确保程序永远不会超出内存?
答案:即使Java提供自动垃圾回收,也不能确保程序不会超出内存,因为与垃圾回收相比,Java对象的创建速度更快。
Q79:main()能否有除void之外的返回类型?
答案:不可以,main()必须返回值为void,程序才能成功执行。
Q80:垃圾回收之后,还能否重新触发并使用该对象?
答案:不能,一旦对象被回收之后,就不再存在于堆栈上,也就不能再次访问和引用了。
Q81:在Java线程编程中,哪个方法是所有线程必须实现的?
答案:Run()是一个Runnable接口的方法,必须由所有线程实现。
Q82:如何在程序中控制数据库连接,且每次只有一个线程可以进行数据库连接?
答案:应用同步的概念来实现,将数据库相关代码hs synchronized关键字的方法中,以便一次只有一个线程可以访问它。
答案:为了处理手动抛出的异常,我们可以使用throw关键字,并在catch中捕获和处理异常。
Q84:如何实现一个类不允许其他类(甚至派生类)创建其对象?
答案:将该类的构造函数声明为private,那么它就不会被其他类访问。
答案:每个对象在创建时都会从堆栈中获取内存空间,被垃圾回收器销毁之后,其空间将被释放重新分配给其它对象。
答案:在创建对象之前,不会分配内存,所以这两个类都没有分配内存。
答案:如果没有异常处理,那么程序将中止,且不会执行异常抛出之后的语句。
Q89:如果定义了一个类定义了多个构造函数,那么是否可以在一个构造函数中调用另一个构造函数?
答案:如果一个类有多个构造函数,那么可以使用this()在一个构造函数中调用另一个构造函数。
答案:匿名类是不能有名字的类,它们不能被引用,只能在创建时用New语句来声明它们。
Q92:应用程序中有多个类,但只有一个main()可以吗?
答案:可以,main()方法是Java应用程序的入口方法,代码总是从特定类的main方法开始。
Q93:如果我想要保留对象的数据以供以后使用,最好的做法是什么?
答案:如果我们在Java的特定块中定义一个新类,那么这个类就被称为局部类,它在局部范围内可用,在其定义的块之外不可用。
Q95:String和StringBuffer都表示String对象,这两个对象之间可以互相比较吗?
Q96:Java提供了哪些API用于集合类的操作?
答案:Java提供了Collection API,可应用于一组对象的,Collection API支持的重要类包括
ArrayList、HashMap、TreeSet和TreeMap。
Q97:Java的类型转换可以将所有其他类转换为布尔类型吗?
答案:不可以,其它原始类型不能转换为布尔类型,布尔类型也不能转换为其它原始数据类型。
答案:方法的重写要求子类的方法的名称及参数必须和所覆盖的方法相同,返回类型可以不同但必须是所覆盖方法的子类。
答案:在继承的情况下,创建派生类的新对象时,首先调用父类的构造函数,然后调用派生类的构造函数。
以上就是整理的100道Java程序员面试问题和答案,希望同学们在学好技术的基础上,也能理解和掌握这些知识,祝大家早日拿到满意的offer!
20套Java精选项目(视频+源码)
扫码回复 “618”
限时免费领取!
以上是关于一个Java类访问权限的选择题和一个判断题的主要内容,如果未能解决你的问题,请参考以下文章
Java基础总结--常用类以及包的访问权限
java基础 java四种访问权限
Java基础面试题
Java 包和访问权限--3
类具有默认访问权限时的 Java 成员访问权限
Java-访问权限