java 方法调用

参考狂神说JAVA

https://www.kuangstudy.com/course

打印输出

重写toString

Apple a = new Apple("红色" , 5.68);
// 打印Apple对象
System.out.println(a);
调用
// 重写toString方法，用于实现Apple对象的"自我描述"
public String toString()
{
    return "一个苹果，颜色是：" + color
            + "，重量是：" + weight;
}

打印可变形参

public class StringDemo
{
    //    public void test(String msg)
//    {
//        System.out.println("只有一个字符串参数的test方法 ");
//    }
    // 因为前面已经有了一个test()方法，test()方法里有一个字符串参数。
    // 此处的长度可变形参里不包含一个字符串参数的形式
    public void test(String... books)
    {
        for (String book:books) {
            System.out.print("****" + book);
        }
        System.out.println();
    }
    public static void main(String[] args)
    {
        StringDemo olv = new StringDemo();
        // 下面两次调用将执行第二个test()方法
        olv.test();
        olv.test("aa" , "bb");
        // 下面将执行第一个test()方法
        olv.test("aa");
        // 下面调用将执行第二个test()方法
        olv.test(new String[]{"aa",""});
    }
}

打印数组

// 将b数组的第3个元素（包括）到第5个元素（不包括）赋为1
Arrays.fill(b , 2, 4 , 1);
// 对b数组进行排序
Arrays.sort(b);
// 输出b数组的元素，将输出[0, 0, 1, 1, 3, 4]
System.out.println("b数组的元素为："+ Arrays.toString(b));
// 对数组arr1进行并发排序
Arrays.parallelSort(arr1);

// final修饰数组变量，iArr是一个引用变量
final int[] iArr = {5, 6, 12, 9};  其中的数组元素是可变的
// 在接口中定义默认方法，需要使用default修饰
default void print(String... msgs)

静态类的调用方法

public class AccessStaticInnerClass
{
	static class StaticInnerClass
	{
		private static int prop1 = 5;
		private int prop2 = 9;
	}
	public void accessInnerProp()
	{
		// System.out.println(prop1);
		// 上面代码出现错误，应改为如下形式：
		// 通过类名访问静态内部类的类成员
		System.out.println(StaticInnerClass.prop1);
		// System.out.println(prop2);
		// 上面代码出现错误，应改为如下形式：
		// 通过实例访问静态内部类的实例成员
		System.out.println(new StaticInnerClass().prop2);
	}
}

函数内调用构造器

//两个参数的构造器
 public Apple(String name , String color)
{
	this.name = name;
	this.color = color;
}
// 三个参数的构造器
public Apple(String name , String color , double weight)
{
	// 通过this调用另一个重载的构造器的初始化代码
	this(name , color);
	// 下面this引用该构造器正在初始化的Java对象
	this.weight = weight;
}

静态变量、代码块的执行顺序

static这里还是顺序结构，从上而下执行的

class Root
{
    static{
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }
    public Root()
    {
        System.out.println("Root的无参数的构造器");
    }
}
class Mid extends Root
{
    static{
        System.out.println("Mid的静态初始化块");
    }
    {
        System.out.println("Mid的普通初始化块");
    }
    public Mid()
    {
        System.out.println("Mid的无参数的构造器");
    }
    public Mid(String msg)
    {
        // 通过this调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数构造器，其参数值："
                + msg);
    }
}
class Leaf extends Mid
{
    static{
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }
    public Leaf()
    {
        // 通过super调用父类中有一个字符串参数的构造器
        super("疯狂Java讲义");
        System.out.println("执行Leaf的构造器");
    }
}
public class Appliction
{
    public static void main(String[] args)
    {
        new Leaf();
       // new Leaf();
    }
}

报错分析

Integer用==比较127相等128不相等的原因

参考链接：https://www.jianshu.com/p/5b2837e063fd
常量池的原因导致的 可以通过System.identityHashCode 查看内存地址

空指针异常

报空指针异常的原因有以下几种： 

1、串变量未初始化； 
2、接口类型的对象没有用具体的类初始化，比如： 
List it；会报错 
List it = new ArrayList()；则不会报错了 
3、当一个对象的值为空时，你没有判断为空的情况。你可以试着把下面的代码前加一行代码： 
if(rb!=null && rb!="") 
改成： 
if(rb==null); 
if(rb!==null&&rb!="") 或者if("").equals(rb)) 
空指针的解决办法： 
       重点关注报错发生的所在行，通过空指针异常产生的两条主要原因诊断具体的错误。
       同时为了避免空指针的发生，最好在做判断处理时将“null”或者空值放于 设定的值之前。
一个小技巧：如果要把某个方法的返回值与常量做比较，把常量放在前面，可以避免调用null对象的equals方法。
譬如： 
    If ("root".equals(userName)) 
　 {....}
    即使userName对象返回了null对象，这里也不会有空指针异常，可以照常运转。

经典值的传递

参数变量

public class demo01 {
    public static void main(String[] args) {
        int mm=0;
        System.out.println(mm);
        exchang(mm);
        System.out.println(mm);
    }
    public static  int exchang(int m){
        m=10;
        return m;
    }
}

输出结果0 0

类变量

public class demo01 {
    public static void main(String[] args) {
        System.out.println(one.mm);
        exchang(one);
        System.out.println(one.mm);
    }
    public static  int exchang(One m){
        m.mm=10;
        return m.mm;
    }
}
class One{
    int mm=20;
}

输出结果20 10

try…catch 捕获异常代码

面试经常会问的问题

try{
	int a=10/0;
	//待捕获代码
} catch(Exception e){
	System.out.println("catch is begin");
	return 1 ;
}finally{
	System.out.println("finally is begin");
	return 2;
}
执行结果
catch is begin
finally is begin
2
然而返回的是return 2 ； 
原因很明显，就是执行了finally后已经return了，所以catch里面的return不会被执行到。
也就是说finally永远都会在catch的return前被执行。（这个是面试经常问到的问题哦！）

编程理解

1、用生活实例解释面向对象 面向过程：买菜 面向对象：点菜 
2、native和volatile关键字的作用！各举个java 例子 synchronized线程同步问题

JDK	是面向开发人员使用的SDK，Java的开发环境和运行环境
SDK	软件开发包，可以包括函数库、编译程序等。
JRE	Java的运行环境，是面向Java程序的使用者，而不是开发者

native

就是java联合C/C++调用底层的驱动文件
 https://www.cnblogs.com/KingIceMou/p/7239668.html 
其中主要是调用了System.loadLibrary() 动态链接库文件

volatile 的原子问题

它主要是遇到个i++ 的线程安全问题 i++不是原子操作: 大致可以分成3步，
1.先从主内存拿到最新的i值，
2.将i加1这个操作保存到操作数栈，
3.从栈中取出i加1的值写回到主内存。
OK，当线程AB同时执行i++操作时，比如线程A先获取时间片，执行完第2步，这是线程A还未执行完，时间片分配给线程B，B顺利执行完所有操作后并同步了主内存，假设我们i的初始值是1，那么此时主内存值是2，因为线程B执行完毕，cpu时间片又回到线程A手上，做第3步操作，此时同步到主内存的值还是2，看，线程A，B各做了一次加1的操作，但最终结果可能是2，cas的作用就来了，他能保证i++操作的原子性，为什么能保证原子性呢？cas可以把上面三个操作合并成一个操作，是原子的。