＜JVM上篇：内存与垃圾回收篇＞03-程序计数器 | 虚拟机栈（四）

public class DynamicLinkingTest {
    int num = 10;
    public void methodA(){
        System.out.println("methodA()....");
    }
    public void methodB(){
        System.out.println("methodB()....");
        methodA();
        num++;
    }
}

/**
 * 说明早期绑定和晚期绑定的例子
 * @author shkstart
 * @create 2020 上午 11:59
 */
class Animal{
    public void eat(){
        System.out.println("动物进食");
    }
}
interface Huntable{
    void hunt();
}
class Dog extends Animal implements Huntable{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    @Override
    public void hunt() {
        System.out.println("捕食耗子，多管闲事");
    }
}
class Cat extends Animal implements Huntable{
    public Cat(){
        super();//表现为：早期绑定
    }
    public Cat(String name){
        this();//表现为：早期绑定
    }
    @Override
    public void eat() {
        super.eat();//表现为：早期绑定
        System.out.println("猫吃鱼");
    }
    @Override
    public void hunt() {
        System.out.println("捕食耗子，天经地义");
    }
}
public class AnimalTest {
    public void showAnimal(Animal animal){
        animal.eat();//表现为：晚期绑定
    }
    public void showHunt(Huntable h){
        h.hunt();//表现为：晚期绑定
    }
}

/**
 * 解析调用中非虚方法、虚方法的测试
 *
 * invokestatic指令和invokespecial指令调用的方法称为非虚方法
 * @author shkstart
 * @create 2020 下午 12:07
 */
class Father {
    public Father() {
        System.out.println("father的构造器");
    }
    public static void showStatic(String str) {
        System.out.println("father " + str);
    }
    public final void showFinal() {
        System.out.println("father show final");
    }
    public void showCommon() {
        System.out.println("father 普通方法");
    }
}
public class Son extends Father {
    public Son() {
        //invokespecial
        super();
    }
    public Son(int age) {
        //invokespecial
        this();
    }
    //不是重写的父类的静态方法，因为静态方法不能被重写！
    public static void showStatic(String str) {
        System.out.println("son " + str);
    }
    private void showPrivate(String str) {
        System.out.println("son private" + str);
    }
    public void show() {
        //invokestatic
        showStatic("atguigu.com");
        //invokestatic
        super.showStatic("good!");
        //invokespecial
        showPrivate("hello!");
        //invokespecial
        super.showCommon();
        //invokespecial:非虚方法,编译期便可知道.
        super.showFinal();
        //invokevirtual
        showFinal();//因为此方法声明有final，不能被子类重写(但是可以直接调用啊.)，所以也认为此方法是非虚方法。备注:虽然invokevirtual一般调用的是虚方法,但是 final修饰的方法例外.
        //虚方法如下：
        //invokevirtual
        showCommon();//没有super调用,且当前类可能重写该方法.所以无法确定.
        //info 在编译期间无法确定下来.首先它不属于父类的方法，是子类中额外加入的功能方法.如果Son的子类对其进行重写,可以构成多态.
        //例:如果存在一个类继承了Son，那具体用的是Son的info还是Son子类的info，编译器就确定不了了
        info();
        MethodInterface in = null;
        //invokeinterface
        in.methodA();
    }
    public void info(){
    }
    public void display(Father f){
        f.showCommon();
    }
    public static void main(String[] args) {
        Son so = new Son();
        so.show();
    }
}
interface MethodInterface{
    void methodA();
}

/**
 * 体会invokedynamic指令
 * @author shkstart
 * @create 2020 下午 3:09
 */
@FunctionalInterface
interface Func {
    public boolean func(String str);
}
public class Lambda {
    public void lambda(Func func) {
        return;
    }
    public static void main(String[] args) {
        Lambda lambda = new Lambda();
        Func func = s -> {
            return true;
        };
        lambda.lambda(func);
        lambda.lambda(s -> {
            return true;
        });
    }
}

/**
 * 虚方法表的举例
 *
 * @author shkstart
 * @create 2020 下午 1:11
 */
interface Friendly {
    void sayHello();
    void sayGoodbye();
}
class Dog {
    public void sayHello() {
    }
    public String toString() {
        return "Dog";
    }
}
class Cat implements Friendly {
    public void eat() {
    }
    public void sayHello() {
    }
    public void sayGoodbye() {
    }
    protected void finalize() {
    }
    public String toString(){
        return "Cat";
    }
}
class CockerSpaniel extends Dog implements Friendly {
    public void sayHello() {
        super.sayHello();
    }
    public void sayGoodbye() {
    }
}
public class VirtualMethodTable {
}

/**
 *
 * 返回指令包含ireturn（当返回值是boolean、byte、char、short和int类型时使用）、
 * lreturn、freturn、dreturn以及areturn，另外还有一个return指令供声明为void的方法、
 * 实例初始化方法、类和接口的初始化方法使用。
 *
 * @author shkstart
 * @create 2020 下午 4:05
 */
public class ReturnAddressTest {
    //构造方法返回指令:return
    public boolean methodBoolean() {
        return false;//ireturn;
    }
    public byte methodByte() {
        return 0;//ireturn;
    }
    public short methodShort() {
        return 0;//ireturn;
    }
    public char methodChar() {
        return 'a';//ireturn;
    }
    public int methodInt() {
        return 0;//ireturn;
    }
    public long methodLong() {
        return 0L;//lreturn;
    }
    public float methodFloat() {
        return 0.0f;//freturn;
    }
    public double methodDouble() {
        return 0.0;//dreturn;
    }
    public String methodString() {
        return null;//areturn;
    }
    public Date methodDate() {
        return null;//areturn;
    }
    public void methodVoid() {//return;
    }
    static {
        int i = 10;
    }
    //
    public void method2() {
        methodVoid();
        try {
            method1();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void method1() throws IOException {
        FileReader fis = new FileReader("atguigu.txt");
        char[] cBuffer = new char[1024];
        int len;
        while ((len = fis.read(cBuffer)) != -1) {
            String str = new String(cBuffer, 0, len);
            System.out.println(str);
        }
        fis.close();
    }
}

Exception   table:
from  to   target  type 
4   16    19     any  //字节码4-16行出任何问题了,按照19行的解决方法处理.
19    21  19     any //字节码19-21行出任何问题了,按照19行的解决方法处理.

/**
 * 面试题：
 * 方法中定义的局部变量是否线程安全？具体情况具体分析
 *
 *   何为线程安全？
 *      如果只有一个线程才可以操作此数据，则必是线程安全的。
 *      如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
 * @author shkstart
 * @create 2020 下午 7:48
 */
public class StringBuilderTest {
    int num = 10;
    //s1的声明方式是线程安全的  内部产生内部消亡就是线程安全的!
    public static void method1(){
        //StringBuilder:线程不安全
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        //...
    }
    //sBuilder的操作过程：是线程不安全的    sBuilder创建后除了当前方法,可能被其他多个线程操作..
    public static void method2(StringBuilder sBuilder){
        sBuilder.append("a");
        sBuilder.append("b");
        //...
    }
    //s1的操作：是线程不安全的  因为有返回值,可能被多个线程抢用.
    public static StringBuilder method3(){
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        return s1;
    }
    //s1的操作：是线程安全的  类似于情况1
    public static String method4(){
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
        return s1.toString();//返回的String可能被多个线程强用,但是StringBuilder是安全的,随着方法的消亡而消亡.
    }
    public static void main(String[] args) {
        StringBuilder s = new StringBuilder();
        new Thread(() -> {//可以看出method2是线程不安全的.
            s.append("a");
            s.append("b");
        }).start();
        method2(s);
    }
}