java -- 容易放错的误区

1.按值传递和引用传递

（基本类型包括基本类型的包装类或者字符串类型传递的是副本并不会改变原来的值）|| 如果是引用类型传递的是地址，会改变原来的值。

public class T {
	public static void main(String[] args) {
		String str = "logo";
		change(str);//传递
		System.out.println(str);//结果：logo
		Integer i = new Integer(10);
		changeInteger(i);//传递
		System.out.println(i);//结果：10
	}
	private static void change(String str){
		str = "change";
	}
	private static void changeInteger(Integer i){
		i=100;
	}
}

	public static void main(String[] args){
		String str = new String("str");
		char [] c = {'1','2','3'};
		char c1 = '0';
		change(str,c,c1);
		System.out.println(str);//str 没变
		System.out.println(c);//{'1','c','3'} 数组 改变
		System.out.println(c1);//'0' 没变
	}
	
	public static void change(String str,char[]c,char c1){
		str = "change";
		c[1]='c';
		c1 = 'P';
	}

2.子类继承父类。方法的重写。方法和返回值类型必须相同

class A {
	protected int method1(int a, int b) throws Exception { return 0; }
 }

class B extends A{// 重写     1.子类的 访问修饰符大于服类  2.抛出的异常小于父类
	public int method1(int a, int b)throws RemoteException { return 0; }
 }

3.类中有静态块块构造方法时初始化的顺序如下：

　　不管是 T t = new T1(); 还是 T1 t = new T1();

　　都是先调用父类的静态块，然后子类的静态块，然后才是父类的块和构造方法，最后子类的块和构造方法

结果如下：

t static {}
t1 static{}
T {}
T()
t1 {}
t1()

import java.lang.reflect.Array;
import java.util.Scanner;


public class T {
	static{
		System.out.println("t static {}");
	}
	{
		System.out.println("T {}");
	}
	
	T(){
		System.out.println("T()");
	}
	public static void main(String[] args) {
		T1 t = new T1();
	}	

}

class T1 extends T{
	static{
		System.out.println("t1 static{}");
	}
	
	{
		System.out.println("t1 {}");
	}
	
	T1(){
		System.out.println(" t1()");
	}
}

4.基本类型的包装类的 == 比较

		Integer a = new Integer(100);// new出来的已分配内存对象
		Integer b = new Integer(100);
		Double c = new Double(10.1);
		Double d = new Double(10.1);
		System.out.println(a==b);//false
		System.out.println(c==d);//false
		
		Integer e = 20;  //自动装配
		Integer f = 20;
		System.out.println(e==f);//true;

5.Object 的 equals 和普通的 equals的区别

如下：

public class Test extends Object{
	public static void main(String[] args) {
		Test o = new Test();
		Test o1 = new Test();
		if(o.equals(o1)){
			System.out.println("aaa");
		}//输出：hello
		 //    aaa
		
		//-------------------
		Object o2 = new Test();
		Object o3 = new Test();
		if(o2.equals(o3)){//false  会调用Object的 equals方法
			System.out.println("bbb");
		}
	}
	
	public boolean equals(Test other){//此方法的 方法参数类型不一样  没有重写Object的equals方法
		System.out.println("hello");
		return true;
	}
	
    public boolean equals(Object obj) {//此为Object的 equals方法重写
        return (this == obj);
    }
}

6.Thread 的start（）和run()的区别一个线程对象只能调用一次start方法.从new到等待运行是单行道,所以如果你对一个已经启动的线程对象再调用一次start方法的话,会产生:IllegalThreadStateException异常.

可以被重复调用的是run()方法。
Thread类中run()和start()方法的区别如下：
run()方法:在本线程内调用该Runnable对象的run()方法，可以重复多次调用；
start()方法:启动一个线程，调用该Runnable对象的run()方法，不能多次启动一个线程；

7.Http 和 Https 的区别

在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。

Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。
http和https使用的是完全不同的连接方式,用的端口也不一样,前者是80,后者是443。http的连接很简单,是无状态的,... 

HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议
要比http协议安全

8.Mybatis 中 ${参数} 和 #{参数}的区别

默认情况下,使用#{}语法,MyBatis会产生PreparedStatement语句中，并且安全的设置PreparedStatement参数，这个过程中MyBatis会进行必要的安全检查和转义。
示例1：
执行SQL：Select * from emp where name = #{employeeName}
参数：employeeName=>Smith
解析后执行的SQL：Select * from emp where name = ？
执行SQL：Select * from emp where name = ${employeeName}
参数：employeeName传入值为：Smith
解析后执行的SQL：Select * from emp where name =Smith

综上所述、${}方式会引发SQL注入的问题、同时也会影响SQL语句的预编译，所以从安全性和性能的角度出发，能使用#{}的情况下就不要使用${}

9.字符串操作比较 ==

		String s = "abc";
		String s1 = s+"";
		System.out.println(s==s1);//false
		String s2 = "abc";
		System.out.println(s==s2);//true;
		String s3 = "ab"+"c";
		System.out.println(s==s3);//true;
		String s4 = '1'+'2'+'3'+"abc";
		System.out.println((int)'1');//49
		System.out.println((int)'2');//50
		System.out.println((int)'3');//51
		System.out.println(s4);//150abc

10. null的强转换后调用static 和非 static方法

public class Test{
	public static void main(String[] args){
		((Test)null).tess();// test 类加载后 可直接调用static方法
		((t5)null).te();// tttt 类加载后 可直接调用static方法
		((t5)null).te1();// NullPointerException 非静态方法报错
	}
	public static void tess(){
		System.out.println("tess");
	}
}
class t5{
	t5(){
		System.out.println("t");
	}
	public static void te(){
		System.out.println("tttt");
	}
	public void te1(){
		System.out.println("t111");
	}
	
}

11.基本数据类型和它的包装类型 == 和 equals 比较都是true

	public static void main(String[] args){
		Integer b = new Integer(5);
		int a = 5;
		System.out.println(a==b);//true
		System.out.println(b.equals(a));//true
	}

12.继承关系中，成员变量是调用方法获得的值，的执行顺序：

public class Su {
    
    String str = get("1 string");//3
    static String ss = get("1 static string");//1
        
    static String get(String string) {
        System.out.println(string);
        return string;
    }
    
    public static void main(String[] args) {
        new s();
    }
}

class s extends Su{
    String s = get("2 string");//4
    static String s2 = get("2 static string");//2
}