1. 静态导入

• • 使用import static方式导入一个类的所有方法. 例如: import static net.mindview.util.Print.*;

　　　　　　首先定义了一个Print类,里面有静态方法print

package net.mindview.util;

public class Print {
    public static void print(Object s){
        System.out.println(s);
    }
}

　　　　　　　使用的时候 在类前使用import static导入即可. 需要手动导入

package net.mindview.operators;

import java.util.Date;
import static net.mindview.util.Print.*;
public class HelloData {

    public static void main(String[] args) {
        print("hello, it is");
        print(new Date());

    }
}

2. java操作符

• 几乎所有的操作符都只能操作"基本类型"

3. 赋值

• • 基本类型存储了实际的数值, 且并非指向一个对象的引用, 所以再赋值的时候, 直接将一个地方的内容复制到了另一个地方,这就是所谓的基本类型是值传递,而对象,String等是地址传递
  • 对象赋值; 将一个对象赋值给另一个对象, 实际上是将"引用"从一个地方复制到另一个地方.这意味着加入c=d,那么c和di都指向了原来d指向的那个对象.

package net.mindview.operators;

class Tank{
    int level;
}

public class Assignment {
    public static void main(String[] args) {
        Tank t1 = new Tank();
        Tank t2 = new Tank();
        t1.level = 27;
        t2.level = 41;
        System.out.println("t1.level:" + t1.level + ", t2.level:" + t2.level);
        t2 = t1;
        System.out.println("t1.level:" + t1.level + ", t2.level:" + t2.level);
        t1.level = 5;
        System.out.println("t1.level:" + t1.level + ", t2.level:" + t2.level);
    }

}

　　这种特殊的现象叫做"别名现象", 是java操作对象的一种基本方式。在这个例子中，如果想辨别名问题应该怎么办呢？ 应该这样写：

　　　　t1.level = t2.level;

　　下面这句话不太理解:

　　这样便可以保持两个对象彼此独立, 而不是将t1和t2绑定到同一个对象上。 但你很快就会意识到， 直接操作对象的域容易导致混乱，并且， 并且违背了良好面向对象程序设计的原则。这可不是一个小问题， 所以从现在开始大家就应该注意， 为对象赋值可能会产生意想不到的结果。

　　我的问题： 什么结果呢？ 假设成员变量不是基本类型， 而是引用类型。 如果给引用类型赋值， 指向的又是一个地址， 这样一个地方改了， 那么使用这个引用地址的地方都会受到影响， 我是这么理解的。 不知道对不对

　　方法调用中的别名现象。也就是参数是一个引用类型, 传递的是引用地址. 一旦在方法内部修改了引用地址的成员变量, 那么所有指向这个引用地址的地方都会被修改.

package net.mindview.operators;

class Letter{
    char c;
}

public class PassObject {
    static void  f(Letter y){
        y.c = 'z';
    }
    public static void main(String[] args) {
        Letter x = new Letter();
        x.c = 'a';
        System.out.println("1: x.c="+x.c);
        //传递的时x所指向的引用
        f(x);
        System.out.println("1: x.c="+x.c);
    }
}

4. 自动递增和递减

• ++i:先运算, 在生成值
• i++: 先生成值, 在运算.

　　记忆方法, 运算都是+1, 如果先生成值, 那么就是没+1之前就生成了, 后生成值, 就是运算后生成的,所以+1了.

package net.mindview.operators;
import static net.mindview.util.Print.*;
public class AutoInc {

    public static void main(String[] args) {
        int i = 1;
        println("i:"+i);
        println("++i:"+ ++i);//先执行运算, 在生成值
        println("i:"+i);
        println("i++:"+ i++);//先生成值, 在运算
        println("i:"+i);
    }

}

输出结果:

i:1
++i:2
i:2
i++:2
i:3

 5. 对象的等价性

package net.mindview.operators;

public class EqualsMethod {

    public static void main(String[] args) {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.println(n1 == n2);
        System.out.println(n1 != n2);
    }
}
/*
　　output: 
　　　　false
　　　　true
*/

• • 这个例子说明了 : == 和 !=比较的是对象的引用
  • 如果想比较两个对象的实际内容是否相同, 必须使用equals()方法。 注意这个规则不适合基本类型，基本类型直接使用==和！=即可。
  • java类库都重写了equals()方法,以便用来比较对象的内容,而不是对象的引用.

6.截尾和舍入

• 29.7转换为int, 结果是30还是29? float转int, 大位数转小位数, 会截去,所以结果是29.
• 如果想要四舍五入,则使用java.lang.Math包中的round方法.
• 通常,表达式中出现的最大的数据类型决定了表达式最终的数据类型. float与double相乘,结果是double类型, int和long相加,结果是long类型.

fasdfasdf

1. fasfasdf
2. fasdfads