Day03 Java基础语法

Java基础语法

注释、标识符、关键字

注释

---

1. 书写注释是一个非常好的习惯
2. 平时代码要注意规范

Java的注释分为三种：

• 单行注释: //注释

• 多行注释： /*注释*/

• 文档注释: JavaDoc： /** */

  /**

  *@Description

  */

标识符

---

1. Java所有组成部分都需要名字。类名，变量名以及方法名统称为标识符。如：public，static， class
2. 所有标识符都应该以字母（A-Z或者a-z），美元符，下划线开始
3. 不能使用关键字作为变量名或者方法名
4. 标识符是大小写敏感的
5. 不建议使用中文以及拼音命名

数据类型

1. Java是一种强类型语言，要求变量使用严格符合规定，所有变量必须先定义才能使用，所以安全性高，与python不同

2. Java的数据类型分为两大类：

   • 基本类型：int 4个字节，short2个字节，long8个字节，byte 1个字节; float4个字节,double8个字节,char2个字节；boolean 占一位

   • 引用类型：类，接口，数组

   float num = 10.1F; //float类型要在数字后面加个F
   long num1 = 30L； //Long类型要在数字后面加个L
   //字符
       char name0 = "国家";
       String name = "love";   //String不是关键字，是一个类
   //布尔值
   	boolean a = true；
   

3. 拓展

   public class demo03 {
          
       public static void main(String[] args) {
          
          //整数拓展，进制，十进制，八进制，十六进制
           int i = 10;
           int i2 = 010;  //八进制0
           int i3 = 0x10;   //十六进制0x
   
           ///================================================
           //浮点数拓展？   银行业务怎么表示？
           //用BigDecimal 数学工具类
           //================================================
           //float   有限的，是离散的，有舍入误差，接近但是不等于
           //double
           //最好完全避免用浮点数进行比较
           //最好完全避免用浮点数进行比较
           //最好完全避免用浮点数进行比较
           float f =0.1f;    //0.1
           double d = 1.0/10;  //0.1
           System.out.println(f==d);   //会输出false
           System.out.println(f);
           System.out.println(d);
           float d1 = 231313131313131313f;
           float d2 = d1 + 1;
           System.out.println(d1==d2);   //会输出true
   
           //==============================================
           //字符拓展
           //==============================================
           char c1 ='a';
           char c2 = '中';
           System.out.println(c1);
           System.out.println((int)c1);   //强制类型转换   输出97
           System.out.println(c2);
           System.out.println((int)c2);   //强制类型转换    输出20013
           //所有字符本质还是数字
           //编码 Unicode表 2个字节   0-65536
           //U000   UFFF
           char c3 = '\u0061';
           System.out.println(c3);   //a
   
           //转义字符
           //  \t  制表符
           //  \n   换行
           //...
           System.out.println("Hello\nWorld!");
           System.out.println("================================================");
           String sa = new String("Hello World");
           String sb = new String("Hello World");
           System.out.println(sa==sb);    //false
   
           String sc = "Hello World";
           String sd = "Hello World";
           System.out.println(sc==sd);     //true
           
           //布尔值拓展
           boolean flag = true;
           if (flag){
           }   //老手
           if (flag==true){
           }   //新手
           //less is more 代码要精简易读
       }
   }
   
   

类型转换

1. 表示数的范围从低到高：byte short int long float double
2. 运算中不同类型的数据类型化为同一类型进行运算

public class Demo4 {
     
    public static void main(String[] args) {
     
        int i =128;
        byte b = (byte)i;   //内存溢出，byte类型最大为127
        //强制类型转换  （类型）变量名
        double c = i;   //自动转换，低到高
        System.out.println(b);

        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换成为不相干的类型
        3.由高到低，强制转换，可能存在内存溢出或者精度问题
        4.
         */
        System.out.println((int)23.7);  //输出23
        System.out.println((int)-45.89f);   //输出-45
        char e = 'a';
        int d = e+1;
        System.out.println(d);
        System.out.println((char)d);   //输出b
    }
}

public class Demo5 {
     
    public static void main(String[] args) {
     
        //操作比较大的数的时候注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        System.out.println(money);
        int year = 20;
        int total = money*year;     //计算的时候溢出了
        System.out.println(total);   //输出-1474836480
        long total2 =  money*year;  //默认int，做完乘法后才转成long的
        System.out.println(total2);  //输出-1474836480
        long total3 = money*((long)year);
        System.out.println(total3);    //输出20000000000


        //L l  大写的L和l的问题，小写的l写在数字后表示long类型时容易被误认为是1，所以都用大写的L
    }
}

变量、常量

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

2. Java变量是程序中最基本的存储单元，其要素包含变量名，变量类型以及作用域

3. type varName [=value] [{,varName[=value]}]

   int a =1, b=3,c=3;

   这种最好分三行写，提升程序的可读性

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

5. 变量名必须是合法的标识符

6. 变量的作用域

   public class Demo08 {
          
       //属性：变量
       static double salary = 2500;
       //实例变量：从属于对象,如果没有进行初始化，默认等于零  0  0.0
       //布尔值默认为false
       //除了基本类型，其余都是NULL
       int age；
       //常量
       static final double PI =3.14;  //static和final这样的修饰符不存在先后顺序，常量尽量大写
       final  static double pi=3.14;
       //main方法
       public static void main(String[] args) {
          
           //局部变量：必须声明和初始化值
           Demo08  demo08 = new Demo08();
           System.out.println(demo08.age);
           System.out.println(salary);
       }
   
       //其他方法
   }
   
   

   7. 变量名的命名规范
      • 所有变量方法以及类名：见名知意
      • 类变量成员：首字母小写和驼峰原则：monthSalary
      • 局部变量：首字母小写和驼峰原则
      • 常量：大写字母和下划线：MAX_VALUE
      • 类名：首字母大写和驼峰原则 GoodMan
      • 方法名：首字母小写和驼峰原则： run（）；runRun（）；

运算符

public class Demo01 {
     

    //ctrl+D 复制当前行到下一行
    public static void main(String[] args) {
     
        int a =10;
        int b =20;
        int c =25;
        int d =25;
         //二元运算符
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);  //除法会有小数的时候一定要注意类型转换
		//一元运算符
        //++   —-   自增   自减
        int a1 =3;
        int b2 = a1++;  //先把a1赋值给b2，再自增
        
        //幂运算    很多运算使用工具类来操作
        double e = Math,pow（2，3）；
        
        //问：2的8次方怎么运算最快
         /*
         效率高
         左移运算<<   *2
         
         右移运算>>   /2
         */
         
            
            //字符串连接   +   ，只要不是在末尾有一方出现String类型的就会把另一方也转成String类型
            System.out.println(""+a+b);   //输出1020
        	System.out.println(a+b+"");    //输出30
        //x?y:z
        //如果x为true则为y，否则为z
    }

}

public class Demo02 {
     
    public static void main(String[] args) {
     
        long a = 12312312313213L;
        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
    }
}

包机制

1. 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
2. 包语句的语法格式为：
   package pkg1[.pkg2[.pkB3.-J]； （包的本质就是文件夹）（这句话必须放在程序的最上面）
3. 一般利用公司域名倒置作为包名；www.baidu.com com.baidu.www
4. 为了能够使用某一个包的成员，我们需要在Java 程序中明确导入该包，使用“import”语句可完成此功能
   import packagel[.packagez…].（classnamel*）；（*表示导入包底下所有的类）

JavaDoc

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