java 面向对象

最新推荐文章于 2024-10-17 10:27:13 发布

w͏l͏j͏

最新推荐文章于 2024-10-17 10:27:13 发布

阅读量107

点赞数

分类专栏： # JavaSE 文章标签： java 类

本文链接：https://blog.csdn.net/qq_40624026/article/details/113177696

版权

JavaSE 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

我们可以重载main方法吗？重写呢？

public class OverLoadTest {
	public static void main(String[] args) {
		main(10);
	}
	public static void main(int a) {
		System.out.println("重载的main");
	}
}
输出结果：重载的main
结论：main方法也是普通方法，我们可以根据我们的需要对其重载，不可以重写main方法，因为main方法也是静态的。

2.Java的构造器返回值？

不,Java构造函数不能返回值。如果需要，只需创建一个构造函数并返回需要的值的方法。例如下面的例子：
public class Tester {
  public Tester(){}
  public static Tester getInstance(){
     Tester tester = new Tester();
      return tester;
  }
}

我们可以创建一个没有main方法的程序吗？

java

从上面的java代码我们可以看出，没有main函数的java程序是无法执行的，java 6之前可以执行，但是java 7
开始之后便修复了这个问题，所以，要想执行一个java程序，这个程序里面必须有main函数。

Java为什么不支持多继承？

多重继承确实使设计复杂化并在强制转换、构造函数链接等过程中产生问题，但是接口只有方法声明而且没有提供任何实现，因此只有一个特定方法的实现，因此不会有任何歧义，接口可以实现多继承。

Java使用static关键字解析？
可以阅读这篇文章，引用的Matrix海子的文章

为什么使用聚合？

我们常用增加接口来提高聚合。聚合聚合，便是把对A的所有操作都放到A里面去，从而实现对A的操作A说了算，
这样的好处是，如果以后我们想了更多操作A的方法，或者想修改以前的方法，都是可以直接在A中进行修改了，
而不用修改其他的类。还有另外一个好处，当完善了A的操作后，我们可以直接在其他类中定义A类的对象，
并实现对A的所有操作，这样就构成了一种has-a的关系，提高了类的重用性。

可以重写静态方法吗？

子类可以继承父类静态方法但是不能重写。这是因为静态方法与类绑定，而实例方法与对象绑定。静态属于类区域，实例属于堆区域。

什么是协变量返回类型？

class A{
A get(){return this;}
}

class B1 extends A{
B1 get(){return this;}
void message(){System.out.println("welcome to covariant return type");}

public static void main(String args[]){
new B1().get().message();
}
}
Compile by: javac B1.java
java B1
welcome to covariant return type
正如您在上面的示例中看到的，一个A类的get()方法的返回类型是A，而B类的get()方法的返回类型是B。
两个方法的返回类型不同，但B是重写的A的方法。这被称为协变返回类型。Java不允许基于返回类型的重载，
但JVM始终允许基于返回类型的重载。 JVM使用方法的完整签名进行查找。

super关键字的三种用处？

1.super可以用来引用父类的直接实例变量。
2.可以使用super来调用直接父类方法。
3.super()可用于调用直接父类的构造函数。

为什么使用实例化初始块？

实例初始值设定项块类似于构造函数。每个对象都会调用一次，可用于设置实例变量的初始值。
实例初始化块是在类的实例创建时创建的。实例初始化块在父类构造函数被调用之后被调用(即在super()构造
函数调用之后)。实例初始化器块按照它们出现的顺序出现。
class A{  
A(){  
System.out.println("parent class constructor invoked");  
}  
}  
class B3 extends A{  
B3(){  
super();  
System.out.println("child class constructor invoked");  
}  
B3(int a){  
super();  
System.out.println("child class constructor invoked "+a);  
}  
 
{System.out.println("instance initializer block is invoked");}  
 
public static void main(String args[]){  
B3 b1=new B3();  
B3 b2=new B3(10);  
}  
}
Output:     parent class constructor invoked
            instance initializer block is invoked
            child class constructor invoked
            parent class constructor invoked
            instance initializer block is invoked
            child class constructor invoked 10

空白final变量的使用？

没有赋值给它的final变量称为空白final变量。它只能在构造函数中初始化，如果不初始化空白的final变量将导致编译错误。使用如下：
public class Demo{
   private static final int val_1;
   private final int val_2;
   static{ val_1 = 1;
   }
   Demo(int val_3){
      val_2 = val_3;
   }
   public static void main(String s[]){
      Demo obj_1 = new Demo(95);
      Demo obj_2 = new Demo(99);
      System.out.println("第一个变量的值为 : ");
      System.out.println(Demo.val_1);
      System.out.println("使用对象访问的第一个变量的值 : ");
      System.out.println(obj_1.val_2);
   }
}
第一个变量的值为 :
1
使用对象访问的第一个变量的值 :
95

接口的标志？

使用interface关键字来声明接口,接口里面的方法都是public abstract

interface <interface_name>{  
   // declare constant fields  
   // declare methods that abstract   
   // by default.  
}

什么是运行时多态或动态方法分派？

运行时多态性或动态方法分派是在运行时而不是编译时解析对重写方法的调用的过程。

使用私有构造器的目的？

私有构造器，就是用private关键字声明的构造器。与一般公有构造器最大的区别在于，其访问权限是private，
于是它只能被包含它的类自身所访问，而无法在类的外部调用，故而可以阻止对象的生成。所以，如果一个
类只有一个私有构造器，而没有任何公有构造器，是无法生成任何对象的。这样的类在实际应用中最常用
的是作为工具类，如字符串的验证、枚举转换之类的，通常只做成静态接口被外部调用即可。

什么是对象克隆？

对象克隆是一种创建对象精确副本的方法。对象类的clone()方法用于克隆对象。这样可以使我们不需要使用显式的代码将一个对象的值赋值给另一个对象。例如：
public class Person implements Cloneable{
   private int age ;
   private String name;
   public Person(int age, String name) {
   	this.age = age;
   	this.name = name;
   }
   public Person() {}
   public int getAge() {
   	return age;
   }
   public String getName() {
   	return name;
   }
   @Override
   protected Person clone() throws CloneNotSupportedException {
   	return (Person)super.clone();
   }
   public static void main(String[] args) throws CloneNotSupportedException {
   	Person aPerson = new Person(18,"wang");
   	Person bPerson = (Person) aPerson.clone();
   	System.out.println(aPerson.age);
   	System.out.println(aPerson.name);
   	System.out.println(bPerson.age);
   	System.out.println(bPerson.name);
   }
}
Output:
18
wang
18
wang