Day 4

 类型转换

低--------------------------------------------------->高
byte, short,char-->int-->long-->float-->double

运算中，不同类型的数据先转换成同一类型，然后进行运算。

强制类型转换
自动类型转换

public class Demo05 {
    public static void main(String[] args) {
        int i1 = 128;
        byte b =(byte) i1;  //内存溢出

        //强制转换    （类型）变量名   高--低
        //自动转换     低--高

        System.out.println(i1);
        System.out.println(b);
        System.out.println("=================================");



        int i2 = 128;
        double d = i2;
        System.out.println(i2);
        System.out.println(d);


        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型，
        3.在把高容量转换到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者精度问题
        */

        System.out.println("=======================");
        System.out.println((int)23.7);            //23  (精度问题)
        System.out.println((int)-45.89f);        //-45   （精度问题）
        System.out.println("======================");

        char c = 'a';
        int i3 = c+1;
        System.out.println(i3);  //98
        System.out.println((char) i3);  //b
    }
}

 拓展

public class Demo06 {
    public static void main(String[] args) {
        //操作比较大的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money * years;//-1474836480,计算的时候溢出了，
        long total2 = money * years;//默认是int，转换之前已经存在问题了，

        long total3 = money * ((long)years);//先把一个数转换为long，
        System.out.println(total3);


        // L  l
    }
}

变量

Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

public class Demo07 {
    public static void main(String[] args) {
        //int a, b, c;
        int a=1,b=2,c=3;   //程序可读性
        String name = "棘布";
        char x = 'x';
        double pi = 3.14;
    }
}

变量作用域

类变量
实例变量
局部变量

public class Demo08 {

    //类变量 static
    static double salary = 2500;

    //属性：变量

    //实例变量：在类里面，从属于对象；如果不自行初始化，会变成这个类型的默认值  0   0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null；
    String name;
    int age;

    //main方法
    public static void main(String[] args) {

        //局部变量：是在方法里，在使用之前必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型 变量名字 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);


        //类变量 static
        System.out.println(salary);
    }

    //其他方法
    public void add(){
        System.out.println();
    }
}

常量

常量：初始化后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
常量名一般使用大写字符。

public class Demo09 {

    //修饰符不存在先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量名的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man、GoodMan
方法名：首字母小写和驼峰原则：run(),runRun()yu

运算符

Java语言支持如下运算符：优先级() 

%：取余，模运算
Java里面的等于用两个=来表示
!=：不等于
&&,||,!：与或非

package operator;

public class Demo01 {
    public static void main(String[] args) {

        //二元运算符
        //Ctrl+D :复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);//30
        System.out.println(a-b);//-10
        System.out.println(a*b);//200
        System.out.println(a/b);//0
        System.out.println(a/(double)b);//0.5
    }
}

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 1212113232323232L;
        int b = 123;
        short c = 10;
        byte d = 8;


        System.out.println(a+b+c+d);//Long
        System.out.println(b+c+d);//Int
        System.out.println(c+d);//Int
        //没有long时，所有非int类型转为int类型
    }
}

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果： 正确，错误     布尔值

        int a = 10;
        int b = 20;
        int c = 22;

        //取余，模运算
        System.out.println(c%a);//2      c/a    22 / 10 = 2 ... 2

        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a>=b);//false
        System.out.println(a<=b);//true
        System.out.println(a!=b);//true
    }
}

package operator;

public class Demo04 {
    public static void main(String[] args) {
        // ++   --    自增，自减  一元运算符
        int a = 3;

        int b = a++;//执行完这行代码后，先给b赋值，再自增
        //a++   a = a + 1

        System.out.println(a);//4
        //a++   a = a + 1
        int c = ++a;//执行完这行代码前，再自增,再给c赋值

        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5
        //先把a=3赋值给b，然后a++，a=4，到++a这一行，先算4+1=5，然后把5赋值给c，结果a=5，b=3，c=5

        //幂运算  2^3  2*2*2 = 8   很多运算，我们会使用一些工具类来操作！
        double pow = Math.pow(3, 2);
        System.out.println(pow);
    }
}

package operator;

//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        //  与(and)   或(or)   非(取反)
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a&&b));//逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a || b:"+(a||b));//逻辑或运算：两个变量有一个为真，结果为true，两个都为假，结果才为假
        System.out.println("! (a && b):"+!(a&&b));//如果是真，则变为假，如果是真，则变为真

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);//false
        System.out.println(c);//5
        //如果没有短路则c=6.

    }
}

package operator;

public class Demo06 {
    public static void main(String[] args) {

        //位运算

        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100 //如果两个位置都为1则为1，否则就为0.
        A|B = 0011 1101 //如果对应位都为0则为0，否则为1.
        A^B = 0011 0001 //如果两个位置相同则为0，否则就为1.
        ~B = 1111 0010  //取反

        2*8 = 16  2*2*2*2
        效率极高
        <<   左移*2
        >>   右移/2

        0000 0000     0
        0000 0001     1
        0000 0010     2
        0000 0011     3
        0000 0100     4
        0000 1000     8
        0001 0000     16
         */

        System.out.println(2<<3);
    }
}

package operator;

//扩展赋值运算符（偷懒）
public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;//a = a + b
        System.out.println(a);
        a-=b;//a = a - b
        System.out.println(a);

        System.out.println("=======================");
        //字符串连接符  +  ,String
        System.out.println(a+b);
        System.out.println(""+a+b);//字符串在前面会拼接
        System.out.println(a+b+"");//字符串在后面依旧会运算
    }
}

package operator;

//三元运算符
public class Demo08 {
    public static void main(String[] args) {

        //   x ?  y :  z
        //如果x==true，则结果为y，否则结果为z

        int score = 80;
        String type = score < 60 ?"不及格":"及格";//必须掌握
        // if
        System.out.println(type);

    }
}

包机制 

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：

package pkg1[ .  pkg2[ . pkg3...]];

一般利用公司域名倒置作为包名；

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能

import com.jibu.base.*;
*代表通配符，导入这个包下所有的类！

JavaDoc

javadoc命令是用来生成自己API文档的

参数信息：

@author作者名
@version版本号
@since指明需要最早使用的jdk版本
@parm参数名
@return返回值的情况
@throws异常抛出情况

javadoc -encoding UTF-8 -charset UTF-8 Doc.java