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");//
    static String ss = get("1 static string");//

    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");//
    static String s2 = get("2 static string");//
}