记录平时使用java时发现的一些细节问题。
1、抽象类中是可以有静态方法的,在被子类继承后可以通过子类的实例化对象调用;也可以直接通过抽象类和子类的类名来调用,就像其他的静态方法一样。同样的静态变量也可以使用相同的方法访问。
实例:
package classTest;
abstract class Person0 {
public static String name = "jack";
public static void sayHello() {
System.out.println("hello");
}
}
class Javaer extends Person0{
}
public class Demo {
public static void main(String[] agrs) {
Person0.sayHello();
Javaer.sayHello();
Javaer a = new Javaer();
a.sayHello();
System.out.println(Person0.name);
System.out.println(Javaer.name);
System.out.println(a.name);
}
}
结果:
hello
hello
hello
jack
jack
jack
2、子类实例化时,默认调用父类的无参构造方法(不管子类的构造器有没有参数,因为子类继承的是父类的属性和方法,只调用父类的无参构造器就可以继承父类的属性和方法,因此不会调用父类的有参构造器),再调用子类的有参/无参构造器。
示例:
package classTest;
class Father {
public Father(){
System.out.println("父类的无参构造方法");
}
public Father(int a ) {
System.err.println("父类的有参构造方法"+a);
}
}
class Son extends Father{
public Son() {
System.out.println("子类中的无参构造方法");
}
public Son(int a ) {
System.out.println("子类中的有参构造方法"+a);
}
}
public class TestExecute {
public static void main(String[] args) {
Son s = new Son();
System.out.println("---------------");
Son a = new Son(5);
}
}
结果:
父类的无参构造方法
子类中的无参构造方法
---------------
父类的无参构造方法
子类中的有参构造方法5
3、类的构造方法可以调用成员方法
在声明对象时,在栈区为对象分配内存存储对象的引用,在new(实例化)时在堆区为对象分配内存存储对象的成员。实例化时会调用构造函数,构造函数再调用成员方法(此时已为成员方法分配内存)
4、声明对象和实例化对象时分别会执行哪些函数
5、去除字符串首尾的双引号
String oldStr = "test";
String newStr = oldStr.substring(1, oldStr.length()-1);
System.out.printf(newStr);
输出结果:test
6、不可实例化的类,比如工具类,使用private修饰构造方法。
7、多线程通过实现Callable()接口和Future()接口创建线程,调用get()方法无法获得返回值
必须在线程执行完成后才可以get到返回值;
package practice;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class thread_test {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//new MyThread().start();
//new Thread(new MyRunnable()).start();
//new Thread(new FutureTask<>(new MyCallable())).start();
System.out.println("======");
System.out.println(new FutureTask<Integer>(new MyCallable()).get());
System.out.println("======");
Callable<Integer> myCallable = new MyCallable();
FutureTask<Integer> fTask = new FutureTask<Integer>(myCallable);
new Thread(fTask).start();
System.out.println(fTask.get());
}
}
class MyThread extends Thread{
public void run() {
System.out.println("继承Thread类创建线程");
}
}
class MyRunnable implements Runnable{
public void run() {
System.out.println("实现Runnable接口创建线程");
}
}
class MyCallable implements Callable<Integer>{
public Integer call() {
System.out.println("实现Callable接口创建线程");
return 1;
}
}