从零开始的Java世界（一）Java基本语法

Java基础语法

1.注释、标识符、关键字

注释

• 单号注释

//单行注释

• 多行注释

/*
 *多行注释
 */

• 文档注释

//文档注释
/**
 * @Author kunyuwan
 * @version 1.0
 */

标识符

• 关键字
  

• Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

标识符注意点

• 所有的标识符都应该以字母（A-Z或者a-z）,美元符（$)、或者下划线（_）开始。
• 首字符之后可以2是字母（A-Z或者a-）,美元符，下划线（_）或数字的任何字符组合。
• 不能使用关键字作为变量名或方法名。
• 标识符是大小写敏感的。
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary、#abc
• 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low。

2.数据类型

• 强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。
• Java的数据类型分成两大类
  • 基本类型（primitive type)
    • Long类型要在数字后面加个L
    • float类型要在数字后面加个F
  • 引用类型（reference type)
    

public class Demo02 {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int num1 = 10;//最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;//Long类型要在数字后面加个L

        //小数：浮点数
        float num5 = 50.1F;//float类型要在数字后面加个F
        double num6 = 3.141592653589;

        //字符
        char name = 'A';
        //字符串,String不是关键字，是个类
        //String namea = "kunyuwan";

        //布尔值:是非
        boolean flag = true;
        //boolean flag=false;
    }
}

什么是字节

• 位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
• 字节（byte）：是计算机数据处理的基本单位，习惯用大写B来表示
• 1B（byte,字节）=8bit（位）
• 字符：是指计算机中使用的字母、数字、字和符号
• 1bit表示一位
• 1Byte表示一个字节 1B=8b
• 1024B=1KB
• 1024KB=1M
• 1024M=1G
• 1024G=1TB

扩展

• 整数扩展
  • 在Java中二进制用ob前缀表示，八进制用0前缀表示，十六进制用0x前缀表示，例如：0b10（2），010（8），0x10（16）
• 浮点数扩展
  • float和double 是有限的，离散的，是会存在舍入误差的。
  • 最好完全避免使用浮点数进行比较。
  • 遇到需要高精度的问题可以使用BigDecimal 数学工作类。

public class Demo03 {
    public static void main(String[] args) {
        //整数扩展        进制    二进制ob    十进制  八进制0 十六进制0x
        int i = 10;
        int i2 = 010;//八进制0~7
        int i3 = 0x10;//十六进制 0~9 A~F 16
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("==========================================");
        //======================================================
        //浮点数扩展?   银行业务怎么表示?钱
        //BigDecimal 数学工具类
        //======================================================
        //float    有限 离散   舍入误差 大约 接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        float f = 0.1f;        //0.1
        double d = 1.0 / 10;   //0.1
        System.out.println(f == d);//false


        float d1 = 231313131313131f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);//true

        //======================================================
        //字符扩展？
        //======================================================
        System.out.println("========================================");
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int) c1);//强制转换
        System.out.println(c2);
        System.out.println((int) c2);//强制转换
        //所有的字符本质还是数字
        //编码  Unicode 表:(97 = a 65 = A )  2字节    0~65536

        //U000 UFFFF
        char c3 = '\u0061';
        System.out.println(c3); // a

        //转义字符
        // \t    制表符
        // \n    换行
        // ........
        System.out.println("Hello\tWorld");

        //
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb);

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);
        //对象  从内存分析


        //布尔值扩展
        boolean flag = true;
        if (flag) {
        }
        if (flag == true) {
        }
    }
}

3.类型转换

• 由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。
  
• 运算中，不同类型的数据先转化位同一类型，然后进行运算
• 强制类型转换
• 自动类型转换

public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;  //内存溢出
        double c = i;
        //强制转换     (类型）变量名    高--低
        //自动转换          低--高

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

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;
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);
    }
}

4.常量、变量

变量

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

type varName [=value]  [{,varName[=value]}];
//数据类型    变量名 = 值   可以使用逗号隔开来声明多个同类型变量
//例如:
int a = 10 ;
double b = 10,c=10;

注意事项：

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

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Variable{
    static int allClicks=0;   //类变量
    String str="hello world"; //实例变量
    public void method{
        int i=0;    //局部变量
    }
}

public class Demo08 {
    //类变量 static
    static double salary = 2500;

    //属性:变量
    //实例变量; 从属于对象；如果不自行初始化，这个类型的默认值
    //布尔值：默认是false
    //除了基本类型，其余的基本null;
    String name;
    int age;
    
    //main方法
    public static void main(String[] args) {
        
        //局部变量;  必须声明和初始化值
        int i = 10;
        System.out.println(i);
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.name);
        
        //类变量 static
        System.out.println(salary);
    }
    
    //其他方法
    public void add() {
    }
}

常量

• 常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值。
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名 = 值;
final double PI=3.14;

• 常量名一般使用大写字符

public class Demo09 {
    //修饰符，不存在先后顺序
    final static double PI = 3.14;

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

变量的命名规范

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则：mouthSalary 除了第一个单词以外，后面的单词首字母大写
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run()，runRun()

5.运算符

Java语言支持如下运算符：

• 算术运算符：+，-，*，/，%，++，–

  • a++是先赋值在自加，++a是先自加在赋值。

   package com.kunyuwan.operator;
   
   public class Demo04 {
       public static void main(String[] args) {
           //++  --  自增    自减  一元运算符
           int a = 3;
           int b = a++;//执行完这行代码后，先给b赋值，再自增
           //a=a+1;
           System.out.println(a);
           //a=a+1
           int c = ++a;//执行这行代码前，先自增，再给b赋值
           System.out.println(a);
           System.out.println(b);
           System.out.println(c);
   
           //幂运算    2*2*2 = 8   很多运算，我们通过工具栏来操作！
           double pow = Math.pow(2, 3);
           System.out.println(pow);
       }
   }
  

• 赋值运算符：=

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

• 逻辑运算符：&&，||，!

  • 逻辑 &&（与）：两个变量都为真才为真

  • 逻辑 ||（或）：两个变量有一个为真就为真

  • 逻辑 ! （非）：如果为真则为假，如果为假为真

  • 在与运算符中，如果前面为false，则后面不进行计算，称为短路现象。

    package com.kunyuwan.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
        }
    }
    
  

• 位运算符：&，|，^，~，>>，<<，>>>（了解！！！）

  • 按位与运算符 & ：两位同时为1，结果才为1，否则为0。

  • 按位或运算符 | ：两位只要有一个为1，其值为1。

  • 按位异或运算符 ^ ：两位的值不同时，结果为1，否则为0。

  • 取反运算符 ~ ：对一个二进制数按位取反，即将0变1，1变0。

  • 左移运算符 << ：将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。类似于*2

  • 右移运算符 >> ：将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。类似于/2

  • 无符号右移运算符 >>>：将一个数的各二进制位全部右移若干位，高位补0，右边丢弃。与右移运算符的区别是负数的计算。

    package com.kunyuwan.operator;
    
    public class Demo06 {
        public static void main(String[] args) {
            /*
            A =     0011  1100
            B =     0000  1101
            -----------------------
            A & B = 0000  1100
            A | B = 0011  1101
            A ^ B = 0011  0001
            ~ B   = 1111  0010
    
            2 * 8 = 16     2*2*2*2
            <<左移    *2
            >>右移    /2
            */
            System.out.println(2 << 3);
        }
    }
    

• 条件运算符：? :

   package com.kunyuwan.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);
       }
   }
  

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

    package com.kunyuwan.operator;
    
    public class Demo07 {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
    
            a += b;//a= a+b
            a -= b;//a= a-b
            System.out.println(a);
    
            //字符串连接符   +   ,再+号运算符两侧出现不同数据类型，则默认转换为最高的数据类型
            System.out.println(a + b);
            System.out.println("" + a + b);     //输出1020
            System.out.println(a + b + "");     //输出30
        }
    }
  

• 该表中优先级按照从高到低的顺序书写，也就是优先级为1的优先级最高，优先级14的优先级最低。

6.包机制、JavaDoc

包机制

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

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

• 一般利用公司域名倒置作为包名 www,baidu.com com.baidu.www
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用“import"语句可完成此功能

import package1 [. package2...].(classsname|*);

JavaDoc

• JavaDoc是一种将注释生成HTML文档的技术，生成的HTML文档类似于Java的API。
• JavaDoc命令是用来生成自己API文档的
• cmd在你文件的目录位置下输入

• Javadoc -encoding UTF-8 -charst UTF-8 Doc.java//会在文件目录下生成文件
  

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

package com.kunyuwan.base;

/**
 * @version 1.0
 * @Author WanKun
 * @since 14
 */
public class Doc {
    String name;

    /**
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception {
        return name;
    }
    // javadoc Doc.java
}

IDEA生成JavaDoc文件的方法

第一步：

第二步：

1. 选择是整个项目还是模块还是单个文件

2. 文档输出路径

3. Locale 选择地区，这个决定了文档的语言，中文就是zh_CN

4. 传入JavaDoc的参数，一般这样写 -encoding UTF-8 -charset UTF-8