java练习总结

记录平时使用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;
	}
}