java基础（4）

数据类型转换

1. 低 -------------------------------------------------> 高（字节大小，容量）

byte , short, char, int , long, float,double

小数优先级大于整数

运算中，不同类型的数据先转化为同一类型，然后进行运算

2. public class Demo03 {
       public static void main(String[] args) {
           int i = 128;
           byte b = (byte)i;   //内存溢出
   ?
           //强制转换     （类型）变量名    高——低
           //自动转换      低——高
   ?
           System.out.println(i);
           System.out.println(b);
   ?
           /*
           注意：不能对布尔值进行转换；
                不能把对象类型i转换为不相关的类型；
                在把高容量转换为低容量时，强制转换；
                转换的时候可能存在内存溢出或精度问题；
            */
   ?
           System.out.println("===========================");
           System.out.println((int)23.7);         //结果23
           System.out.println((int)-45.89f);      //结果45
   ?
           System.out.println("============================");
           char c = ‘a‘;
           int d = c+1;
           System.out.println(d);                   //98
           System.out.println((char)d);             //b
   ?
           System.out.println("=============================");
           int money = 10_0000_0000;
           int year = 20;
           int total = money*year;                  //-1474836480，计算的时候内存溢出了
           long total1 = money*year;                //-1474836480，默认是int，先用int计算出结果，转换之成long之前已经溢出了
           long total2 = money*((long)year);        //200000000000，先把一个数转换为long，改精度    （long一般用L）
           System.out.println(money);               //1000000000
           System.out.println(total);
           System.out.println(total2);
       }
   }
   ?

3. 变量：

   可以变化的量，操作内存中的空间。变量代表（内存中的）一块空间，空间的位置是固定的，但这块空间中按变量名分成几块 不一定；

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

数据类型 变量名 = 值；

每个变量都有类型，类型可以是基本类型，也可以是引用类型。

变量名必须是合法的标识符。 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        String name = "qinjiang";
    }
}

4. 变量作用域：类变量 实例变量 局部变量

   public class Demo05 {
       //类变量 static,从属于这个类，随着这个类一起出来，一起消失；
       static double salary = 2500;
       
       //属性：变量
       
       //实例变量：在类里面，从属于对象，通过这个类，才能使用它。如果不自行初始化，默认值：数值类型0  0.0  字符串变量u0000
       //布尔值：默认是false；
       //除了基本类型，其余的默认值都是null；
       String name;
       int age;
       
       //方法块：作用域高，在方法内有效。
       static{
           
       }
       
       //main方法（主程序方法）
       public static void main(String[] args) {
           
           //局部变量：生命周期在这个方法内，使用时必须声明和初始化值，只在这个方法内有效。
           int i = 10;
           System.out.println(i);
           
           //变量类型（自定义的变量类型【引用类型】）  变量名字（对象）   = new Demo05();(相当于把这个类拿到了)
           Demo05 demo05 = new Demo05();
           System.out.println(demo05.age);
           System.out.println(demo05.name);
           
           //类变量 static
           System.out.println(salary);
       }
       
       //其他方法:
       public void add(){
           System.out.println(i);
       }
   }
   ?

5. 常量：初始化后不能再改变的值，不会变动的值。 final 常量名 = 值；

public class Demo06 {
?
    //修饰符不区分先后顺序，变量类型前都是修饰符,常量名一般用大写字符，static是静态常量。
    static final double PI = 3.14;
?
    public static void main(String[] args) {
        System.out.println(PI);   //引用PI
    }
}
?

6. 所有变量、方法名、类名：见名如意

   类成员变量： 首字母小写和驼峰原则：monthSalary

   除了第一个单词以外，后面的单词首字母大写

   局部变量：首字母小写和驼峰原则

   常量： 大写字母和下划线： MAX_VALUE

   类名：首字母大写和驼峰原则：Man,GoodMan

   方法名：首字母小写和驼峰原则：run(),runRun()

7. 运算符：算数运算符：+，-，*，/，%，++，--；

   赋值运算符：=

关系运算符：>，<,>=,<=,==,!= instanceof

逻辑运算符：&&,||,!

位运算符：&,|,^,~,>>,<<,>>>

条件运算符：? :

扩展赋值运算符：+=,-=,*=,/=

package operator;            //代表当前的包(文件夹)
?
public class Demo01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 31;
        int d = 40;
?
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);
?
        long e = 123123123123123L;
        int f = 123;
        short g = 10;
        byte h = 8;
        double i = 1.5;
?
        System.out.println(e+f+g+h);    //有long类型，输出结果为long类型
        System.out.println(f+g+h);      //其他均为int类型
        System.out.println(g+h);        //其他均为int类型（哪怕是小的类型,不管有没有int类型，结果也是int类型）
        System.out.println(g+h+i);      //有double类型，输出结果为double类型
        System.out.println(f+g+h+i);
?
        //关系运算符
        System.out.println(c%a);        // 1  c/a  =  3...1
        System.out.println(a>b);        //false
        System.out.println(a<b);        //true
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}
?

8. ++、--

package operator;
?
public class Demo02 {
    public static void main(String[] args) {
        //++ --  自增自减
        int a = 3;
        int b = a++;    //a++   a = a + 1,a先赋值给b，再自增；    b=3
        //a++   a = a + 1
        System.out.println(a);         //  a=4
        //a++   a = a + 1
        int c = ++a;    //++a   a = a + 1,a先自增,再赋值给c；    c=5
?
        System.out.println(a);         //  a=5
        System.out.println(b);
        System.out.println(c);
        
        //幂运算：2^3  2*2*2 = 8     很多运算，我们会使用一些工具类操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);       //pow = 9
        
    }
}
?

9. 逻辑运算符：&&,||,!

   package operator;
   ?
   public class Demo03 {
       public static void main(String[] args) {
           //and（全1出1）    or（有1出1）     非（取反）
           boolean a = true;
           boolean b = false;
   ?
           System.out.println("a && b:"+(a&&b));      //用加号把字符串"a && b:"（实际是a && b）和结果(a&&b)[加括号优先计算]拼接到一起
           System.out.println("a || b:"+(a||b));
           System.out.println("!(a && b):"+!(a&&b));
   ?
           //短路运算
           int c = 5;
           boolean d = (c<4)&&(c++<4);    //判断前一项为假，不会执行后面的代码，直接返回false，所以后面的c++没有执行，c仍未5.
           System.out.println(d);    //false
           System.out.println(c);    //c=5
       }
   }
   ?

10. 位运算符：&,|,^,~,>>,<<,>>>

    package operator;
    ?
    public class Demo {
        public static void main(String[] args) {
            /*
            A = 0011 1100
            B = 0000 1101
    ?
            A&B = 0000 1100
            A/B
            A^B   异或（不同为1）
            ~B    非
    ?
             2*8 = 16   2*2*2*2 = 16  位运算  速度最快
             <<左移   *2
             >>右移   /2
    ?
             0000 0000   0
             0000 0001   1
             0000 0010   2
             0000 0100   4
             0000 1000   8
             0001 0000   16
             */
            System.out.println(2<<3);    //结果是16
    ?
            //a+=b;    a=a+b
            //a-=b;    a=a-b
    ?
            //字符串连接符  +   String
            // 在加号运算符两侧，只要出现了String类型，就会把另外一个操作数都转换成String,再进行连接。
            int a = 10;
            int b = 20;
    ?
            System.out.println(""+a+b);     //结果是1020
            System.out.println(a+b);        //结果是30
            System.out.println(a+b+"");     //结果是30，前面已经运算完了，优先级问题
    ?
            //条件运算符
            //x ? y : z
            //如果x==true,则结果为y,否则结果为z;
            int score = 80;
            String type = score <60 ?"不及格":"及格";    //写上String type把（score <60 ?"不及格":"及格"）的结果接收一下，type这个类型
            System.out.println(type);
        }
    }
    优先级()：百度上查阅

11. 包机制：一般利用公司域名倒置作为包名；com.baidu.www import

按住Ctrl+鼠标右键可以跳转到类界面，对应的jar包；

导入对应的包，才能用包下面的类，import com.zhz.base.Demo02;导入这个路径的类Demo02;

import com.zhz.base.*;导入这个包内所有的类，通配符（阿里巴巴开发手册）；

12. jdk帮助文档：Oracle官方 核心8，在线的API帮助文档

13. javadoc命令是用来生成自己API文档的 参数信息 @author 作者名 @version 版本号 @since 指明需要最早使用的jdk版本 @param 参数名 @return 返回值情况 @throws 异常抛出情况

    使用cmd指令生成doc文档：javadoc -encoding UTF-8 -charset UTF-8 文件名.java

14. 学会使用IDEA生产javadoc文档，百度搜索

java基础（4）

原文：https://www.cnblogs.com/zhzred/p/14288028.html