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
}

 

 

posted @ 2017-01-05 14:47  K____K  阅读(225)  评论(0编辑  收藏  举报