thinking in java逍遥游记 之 夜的第三章

总结： 本章重点：    1.  对象和变量在堆栈中的运行机制，记住一点，永远都是复制品。其实就是真假美猴王嘛！！！！！！

                                   2.  == 和equals方法的区别：

                                       == 是表示两个对象是否相等

                                       equals对于基本数据类型的对象来说，是比较值是否相等，但是对于一般对象来说，就是指两个引用是否相等。

                                  3.   基本数据类型的转型记住两个原则：   提升原则和窄化原则！！！！！！！！！！！！！！！！！！

                                          提升原则：byte，char，short 相乘之后类型为int，float类型乘以double类型结果为double，总之是提升。

                                                              系统可以自动的向上转型。

                                          窄化原则：向下转型的时候，可能造成数据的丢失。并且需要强制进行转换。

               细节： 1. int * int 有可能溢出，也不是说一定安全，数据不会丢失。

                             2. System.out.println一个好玩的现象

                             3.  窄化的时候是直接去尾，而不是四舍五入。如想四舍五入的话，使用round方法。

                             4. 表达式短路的现象。

                             5. 使用static引入包，可以少写一点代码，但是用时要谨慎。

package com.huxin.thinkinginjava.third;

//equals方法对于基本数据类型，比较的是数值，对于对象，比较的是引用。
public class EqualsTest {
 public static void main(String[] args) {
     Integer i1 = new Integer(47);
     Integer i2 = new Integer(47);
     System.out.println(i1==i2);     //false
     System.out.println(i1.equals(i2));  //true
       
     Test2 test1 = new Test2();
     Test2 test2 = new Test2();
     test1.value = test2.value = 12;
     System.out.println(test1.equals(test2));  //false
 }
}
class Test2{
 int value = 0;
}

/*
 *  关于转型：记住一个原则
 *  提升原则，窄化原则！！！！！！！！！！！！！！
 *
 */
public class CastingTest {
 public static void main(String[] args) {
        int i = 200;
        long j = i;             //等同于     long j = (long)i; 系统会自动的转化，不需要强制转换
        System.out.println(j);
       
        long k = 15;
        int z = (int)k;         //向下转型，系统不会自动的转化，并且需要强制的转换。并且会造成数据的丢失。
        System.out.println(z);
       
        //窄化原则！！！
        float fvalue = 2.9f;
        int  value = (int)fvalue;
        System.out.println(value);    //向下强制转换，不会四舍五入，而是直接去尾。
       
        //提升原则！！！
        byte b  = 14;
        short c = 3;
        System.out.println((byte)(b*c)); 
 }
}

 

//这是一个表达式短路的现象
public class ExpressShort {

 public static void main(String[] args) {
  System.out.println(fun1(0)&&fun2(3)&& fun3(100));    //false
 }
 public static boolean fun1(int i){
  return i<1;
 }
 
 public static boolean fun2(int i){
  return i<2;
 }
 public static boolean fun3(int i){
  System.out.println("哈哈，其实我没有被执行");
  return false;
 } 
}

 

import static java.lang.System.*;
import static java.lang.Math.*;  // 可以导入某一个的类的全部静态Field，可以简化代码

public class StaticImportTest {
 public static void main(String[] args) {
         out.println(sqrt(256));     //sqrt方法返回的是一个double的类型
 }
}

 

public class StringOperators {
 public static void main(String[] args) {
  int x = 10;
  int y = 20;
        System.out.println("有趣的现象"+x+y);
        System.out.println(x+y+"这是它们的和");   //根据上下文进行推断，是连接符，还是运算符。
 }
}

//彻底理解值传递在内存中的执行过程
public class ValueCopy {
 public static void main(String[] args) {
  AssignMent a1 = new AssignMent();
  AssignMent a2 = new AssignMent();
  a1.level = 10;
  a2.level = 20;
  a1 = a2;
  System.out.println(a1.level);
 }
}
class AssignMent{
 int level = 0;
}