java 基础

JAVA 字符串

参考资料：
一张图让你明白 java string 的 内存分配
java 字符串内存分配的分析与总结
常量池，堆，栈

  String s3 = new String("i love china");

如上代码，建立了几个对象？
两个

• 一个是i love china对象，放入常量池中（然后在把这个对象作为参数，传递进去）
• 构造函数创建new String对象。
• 然后在栈中变量s3存放了一个指针，指向new String对象

    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

验证：

        String t1 = "abc";
        String t = new String("abc");
        String t2=t.intern();


        System.out.println(t1== t); //result = false
        System.out.println(t1== t2); //result = true

java参数的传递

值传递
参考资料：https://www.cnblogs.com/9513-/p/8484071.html

父子类多态

public class Fu {
    public int num = 100;

    public void show() {
        System.out.println("show Fu");
        System.out.println(this.num);
    }

    public static void function() {
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    @Override
    public void show() {
        System.out.println("show Zi");
        System.out.println(this.num);
    }

    public void method() {
        System.out.println("method zi");
    }

    public static void function() {
        System.out.println("function Zi");
    }
}

class DuoTaiDemo {
    public static void main(String[] args) {
        //要有父类引用指向子类对象。
        //父 f =  new 子();
        Fu f = new Zi();
        System.out.println(f.num);  //输出为父类变量100
        //报错，找不到
        //System.out.println(f.num2);

        f.show();  //输出为子类方法及变量
         //报错，找不到
        //f.method();
       // f.function();
    }
}

匿名类

https://www.cnblogs.com/chenssy/p/3390871.html
在使用匿名内部类的过程中，我们需要注意如下几点：

1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

public class Test1 {
    public void test(Product p) {
        System.out.println("购买了一个" + p.getName() + ",花掉了" + p.getPrice());
    }

    public void test1(Device d)
    {
        System.out.println("方法1，购买了一个"+d.getName()+",花掉了"+d.getPrice());
    }

    public static void main(String[] args) {
        Test1 tt = new Test1();

        String testFinalVal="haha";
        //jdk1.8默认增加语法糖，后续如果未改变，则增加final标志，否则报错
        int a=10;

        //此处调用test方法时，需要传入一个Productt参数
        //此处传入其匿名实现类的实例,不带构造函数
        tt.test(new Product() {
            @Override
            public double getPrice() {
                System.out.println(testFinalVal);
                //Error:(30, 36) java: 从内部类引用的本地变量必须是最终变量或实际上的最终变量
               //System.out.println(a);
                return 567.8;
            }

            @Override
            public String getName() {
                return "AGP显卡";
            }
        });

        //带有构造函数
        tt.test1(new Device("电子示波器"){
            @Override
            public double getPrice()
            {
                return 67.8;
            }
        });
        a=11;
    }
}

interface Product {
    double getPrice();
    String getName();
}

abstract class Device
{
    private String name;
    public abstract double getPrice();
    public Device(){}
    public Device(String name)
    {
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

上面例子中，演示了从接口、抽象类实现匿名类的过程。匿名内引入外部变量，需要设置为final，原理上就是闭包问题，java将外部自由变量通过构造函数，传递进去了，里面改变，外部不会改变，但是如果不为final。从里面改变了，外部看着效果就不对了

一个依赖于外部环境自由变量的函数
这个函数能够访问外部环境里的自由变量

自动拆装箱

public class TestInterger {
    public static void main(String[] args) {
        test();
    }

    public static void test() {
        int i = 40;
        int i0 = 40;
        Integer i1 = 40;
        Integer i2 = 40;
        Integer i3 = 0;
        Integer i4 = new Integer(40);
        Integer i5 = new Integer(40);
        Integer i6 = new Integer(0);
        Double d1=1.0;
        Double d2=1.0;

        System.out.println("i=i0\t" + (i == i0));  //  true
        System.out.println("i1=i2\t" + (i1 == i2));//  true
        System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));//  true
        System.out.println("i4=i5\t" + (i4 == i5));//  false
        System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));//  true
        System.out.println("d1=d2\t" + (d1==d2));//  false

        System.out.println();
    }
}

参考资料：
https://www.jianshu.com/p/0ce2279c5691

Arrays.asList 坑

参考资料：
https://blog.csdn.net/xlgen157387/article/details/91376347

• 平时的list我们是 java.util.ArrayList。
• Arrays.asList转化出来的类是 java.util.Arrays.ArrayList,因为它没有重写add,remove方法，所以一旦初始化元素后，集合的size就是不可变的。
• Arrays.ArrayList将外部数组的引用直接通过“=”赋予内部的泛型数组，所以本质指向同一个数组。

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

1、不可使用基础类型

由于Arrays.ArrayList参数为可变长泛型，而基本类型是无法泛型化的，所以它把int[] arr数组当成了一个泛型对象，所以集合中最终只有一个元素arr。