面向对象（上）
1.对象和对象引用之间的区别是什么？请举例说明。
- 所在内存空间不同：类和对象被分配到堆中，而对象引用则被分配到栈里面。
- 定义不同：对象是客观事物的抽象，而引用对象则像是对象的名片，存有对象的地址，可以通过引用对象来查找到对象。
2.对象作为参数传递的特点是什么？请举例说明
基本类型作为参数在方法中的传递是值传递，而对象是引用传递
3.对象初始化顺序是怎样的？请举例说明
对象的初始化顺序是系统对数据成员进行默认初始化、执行数据成员定义处的初始化语句、调用构造函数进行初始化。
4.类的static字段与非static字段的区别是什么？什么场景应该使用static修饰符？请举例说明
static修饰符修饰的域变量不属于任何一个类的具体对象，被保存在类的内存区的公共储存单元中，而不是保存在某个对象的内存区域内；而非static字段只能用对象引用，属于某一对象。当对象中出现共享数据时，就一应该使用static修饰。
5.Java中final修饰符都有什么作用？请举例说明
- 修饰类：表示该类不能被继承；
- 修饰方法：表示方法不能被重写；
- 修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。
6.Java中float[10] arr; 语句正确么？为什么？
不正确。定义数组时不能在[ ]中指定大小。
7.Java数组元素类型为基本类型和引用类型时，有什么不同？请举例说明
前者储存的是基本数据类型，而后者是引用对象的地址。
面向对象（中）
1. Java的访问控制修饰符有哪些？各有什么访问权限？
类的访问控制符只能是空或者 public，方法和属性的访问控制符有 4 个，分别是 public、 private、protected 和 friendly，其中 friendly 是一种没有定义专门的访问控制符的默认情况。
- private:用 private 修饰的类成员，只能被该类自身的方法访问和修改，而不能被任何其他类（包括该类的子类）访问和引用。因此，private 修饰符具有最高的保护级别。例如，设 PhoneCard 是电话卡类，电话卡都有密码，因此该类有一个密码域，可以把该类的密码域声明为私有成员。
- friendly（默认）:如果一个类没有访问控制符，说明它具有默认的访问控制特性。这种默认的访问控制权规定，该类只能被同一个包中的类访问和引用，而不能被其他包中的类使用，即使其他包中有该类的子类。这种访问特性又称为包访问性(package private)。同样，类内的成员如果没有访问控制符，也说明它们具有包访问性，或称为友元(friend)。定义在同一个文件夹中的所有类属于一个包，所以前面的程序要把用户自定义的类放在同一个文件夹中(Java 项目默认的包)，以便不加修饰符也能运行。
- protected:用保护访问控制符 protected 修饰的类成员可以被三种类所访问：该类自身、与它在同一个包中的其他类以及在其他包中的该类的子类。使用 protected 修饰符的主要作用，是允许其他包中它的子类来访问父类的特定属性和方法，否则可以使用默认访问控制符。
- public:当一个类被声明为 public 时，它就具有了被其他包中的类访问的可能性，只要包中的其他类在程序中使用 import 语句引入 public 类，就可以访问和引用这个类。
2.子类对于从父类继承的哪些属性与方法是可见的？
public和protected是可见的
3.什么是组合？有什么作用？请举例说明
组合是通过现有的对象进行拼装产生新的、更加复杂的功能。
public class Point {
private int x,y;
public Point(int x,int y) {
this.x = x;
this.y = y;
}
public int GetX() { return x; }
public int GetY() { return y; }
}
class Line {
private Point p1,p2;
Line(Point a, Point b) {
p1 = new Point(a.GetX(),a.GetY());
p2 = new Point(b.GetX(),b.GetY());
}
}
4.什么是重载？有什么作用？请构造各种重载示例。
重载：方法名称相同，参数类型或个数不同。重载可以对其功能进行复用，同时又可以对其进行补充。
class Parent{
public int getScore(){
return 3;
}
public int getScore(int i){
return i;
}
}5.什么是覆写？有什么作用？覆写父类方法的条件有哪些？请举例说明。
子类对父类的同名方法（方法名称相同，参数相同，返回类型相同）重新进行定义，即在子类中定义与父类中已定义的同名而内容不同的方法。
class A {
public void print() {
System.out.println("Hello World");
}
}
class B extends A {
public void print() {
System.out.println("你好！");
}
}
public class Test {
public static void main(String args[]) {
B b = new B();
b.print(); // 方法从父类继承而来
}
}
面向对象（下）
1. 如何实现两个对象之间互发消息，请举例说明
- 应用必须真实引用了特定的对象，否则会在运行时抛出NullPointerException异常。
- 被访问的对象必须定义了相应的属性和方法，否则编译不会通过。
- 被访问的属性和方法必须要有可访问的权限。
class FighterPlane {
private String name;
private int missileNum;
private A a;
public void setA(A _a){
if (_a !=null) { a = _a ;}
}
public A getA(){
if (a !=null)
{ return a;}
else return null;
}
public void fire(){ ……}
public FighterPlane(String _name,int _missileNum){ ……}
class A
{
FighterPlane fp;
public A(FighterPlane fpp){
this.fp = fpp;
fpp.setA(this);//将当前对象传给FighterPlane
}
public void invoke(){
//A中对象发送消息给FighterPlane的对象
fp.fire();
}
}
public class Run{
public static void main(String[] args)
{
FighterPlane ftp = new FighterPlane("su35",10);
A a = new A(ftp);
a.invoke(); }
}2. 谈谈组合与继承的区别以及两者的使用场景。（即什么时候宜用组合 ？什么时候宜用继承？）
组合与继承的区别：
继承是子类继承父类，父类的所有属性和方法都可以被子类访问和调用。组合是指将已存在的类型作为一个新建类的成员变量类型，两个类之间无上下级关系。
使用场景：
当你只需要使用另外一个类的方法时使用组合。但是如果你需要使用另外一个类的作用时但你不想被其他的类访问用继承。
3. Java中的运行时多态的含义是什么？有什么作用？请举例说明。
运行时的多态：方法覆盖实现（子类覆盖父类方法）
父类的引用指向子类对象，调用的方法子类的方法
//父类
class A {
void fun()
{
System.out.println(“I am A”);
}
}
//A的子类B
class B extends A
{
void fun()
{
System.out.println(“I am B”);
}
}
//A的子类C
class C extends A
{
void fun()
{
System.out.println(“I am C”);
}
}
class Test
{
public static void main(String[] args)
{
//定义父类对象引用变量
A a;
//子类对象
B b = new B();
C c = new C();
//父类对象引用变量 引用 子类对象
a=b;
a.fun(); //输出 I am B
a=c;
a.fun(); // //输出 I am C
}
}4.举例说明运算符instanceof的使用场景。
instanceof属于java关键字之一，instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：boolean result = obj instanceof Class
其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。
public class Test {
static class A{ }
static class B extends A{ }
public static void main(String[] args) {
A a = new A();
B b = new B();
System.out.println( "a instanceof A 的结果:" + ( a instanceof A ) );
System.out.println( "b instanceof A 的结果:" + ( b instanceof A ) );
System.out.println();
System.out.println( "a instanceof B 的结果:" + ( a instanceof B ) );
System.out.println( "b instanceof B 的结果:" + ( b instanceof B ) );
System.out.println();
/*
注意:
下面用Object类对象引用某个类实例 是实际应用中非常常见的
object instanceof class ,如果object 实际引用的对象实例 是 class 的实例对象
或者 class 的子类实例对象，则返回true
注意 “实际引用的对象实例” 这个词强调的'实际引用'.
*/
Object o = new A();
System.out.println( "o instanceof A 的结果:" + ( o instanceof A ) );
System.out.println( "o instanceof B 的结果:" + ( o instanceof B ) );
System.out.println();
o = new B();
System.out.println( "o instanceof A 的结果:" + ( o instanceof A ) );
System.out.println( "o instanceof B 的结果:" + ( o instanceof B ) );
System.out.println();
}
}5.谈谈抽象类与接口的异同以及两者的使用场景
相同点：
（1）都不能被直接实例化，都可以通过继承实现其抽象方法。
（2）都是面向抽象编程的技术基础，实现了诸多的设计模式。
不同点：
（1） 接口支持多继承；抽象类不能实现多继承。 接口只能定义抽象规则；
（2）抽象类既可以定义规则，还可能提供已实现的成员。 接口是一组行为规范；
（3）抽象类是一个不完全的类，着重族的概念。 接口可以用于支持回调；
（4）抽象类不能实现回调，因为继承不支持。 接口只包含方法、属性、索引器、事件的签名，但 不能定义字段和包含实现的方法；
（5）抽象类可以定义字段、属性、包含有实现的方法。 接口可以作用于值类型和引用类型；
（6）抽象类只能作用于引用类型。例如，Struct就可以继承接口，而不能继承类。
（7）抽象类有构造方法,接口却没有构造方法。
接口的应用场合：
- 类与类之前需要特定的接口进行协调，而不在乎其如何实现。
- 作为能够实现特定功能的标识存在，也可以是什么接口方法都没有的纯粹标识。
- 需要将一组类视为单一的类，而调用者只通过接口来与这组类发生联系。
- 需要实现特定的多项功能，而这些功能之间可能完全没有任何联系。
抽象类的应用场合：
- 定义了一组接口，但又不想强迫每个实现类都必须实现所有的接口。可以用abstract class定义一组方法体，甚至可以是空方法体，然后由子类选择自己所感兴趣的方法来覆盖。
- 某些场合下，只靠纯粹的接口不能满足类与类之间的协调，还必需类中表示状态的变量来区别不同的关系。abstract的中介作用可以很好地满足这一点。
- 规范了一组相互协调的方法，其中一些方法是共同的，与状态无关的，可以共享的，无需子类分别实现；而另一些方法却需要各个子类根据自己特定的状态来实现特定的功能
扫一扫
734
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
