Java基础

注释和项目

注释

平时写代码的时候，代码量比较少的时候，我们还可以看懂自己写的东西，当项目很大很复杂的时候，我们就需要注释帮我们理解代码了。

• 注释不会执行，注释是写给开发人员看的
• 写注释是一个非常良好的习惯
• 平时写代码要养成良好的编码习惯，注意规范

		//这是单行注释
        
        /*
        这是多行注释
        这是多行注释
        这是多行注释
        这是多行注释
         */

        //JavaDoc:文档注释
        /**
         * @Description HelloWorld
         * @Author Siming
         */

好玩的东西：搜索”有趣的代码注释“

修改注释颜色

创建空项目

New Project-->Empty Project-->module-->Project structure

1. 创建一个空项目
2. 创建模块
3. 设置项目结构

标识符和关键字

标识符

Java 所有的组成部分都需要名字。类名、变量名、方法名都叫做标识符。

使用标识符注意点

• 标识符首字母可以用大小写字母、美元符号$、下划线_开始。
• 首字母后可以用大小写字母、美元符号$、下划线_、数字。
• 不能用关键字作为方法名和变量名。
• 标识符是区分大小写的
• 正确标识符举例：Age、age、$salary、_value、__1value
• 错误标识符举例：123abc、-salary、#abc

关键字

在Java中有特殊意义的单词，不能作为变量名或方法名。

数据类型

强类型语言

• 要求变量的使用必须符合语法规则，变量必须先定义后使用。例如：C/C++、Java都是强类型语言。

弱类型语言

• 例如：变量的使用没有严格限制语法，JavaScript是强类型语言。

Java数据类型分为两大类

• 基本类型（primitive type）
• 引用类型（reference type）

什么是字节？

• 位（bit）：位是计算机 内部数据 存储的最小单位，例如11001100是一个八位二进制数。
• 字节（byte）：字节是计算机中 数据处理 的基本单位，一般用大写B来表示。
• 1B=8bit，即一个字节=8个比特。
• 字符：是计算机中使用的字母、数字、文字和符号。

存储容量换算

• 1B = 8bit
• 1KB = 1024B
• 1M = 1014KB
• 1G = 1024M
• 1T = 1024G

数据类型拓展

public class IntegerPlus {
    public static void main(String[] args) {
        //整数拓展：进制       二进制  八进制  十进制  十六进制

        int i1 = 0b10;      // 二进制0b,0b10表示2
        int i2 = 010;       // 八进制0,010表示8
        int i3 = 10;        // 十进制10,表示10
        int i4 = 0x10;      // 十六进制0x10,0x10表示16

        //浮点数拓展    银行业务怎么表示钱？
        //银行业务不能用float和double，要用BigDecimal，是一个数学工具类
        /*
        浮点数表示出来的数是有限的，但有些数除不尽是离散的，
        浮点数的尾数会四舍五入，这会损失精度。得到的数只是原数据的大约。
        所以最好避免使用浮点数进行比较
        所以最好避免使用浮点数进行比较
        所以最好避免使用浮点数进行比较
         */
        float f = 0.1f;
        double d = 1.0/10;
        System.out.println(f==d);   //false

        float f1 = 23323323232323332323f;
        float f2 = f1 + 1;
        System.out.println(f1==f2); //true

        //字符拓展
        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)

        char c3 = ‘\u0061‘;     // 十六进制0x61表示十进制数字97，即a
        System.out.println("c3=" + c3);

        //转义字符
        // \t 制表符   \n 换行符
        // 还有很多转义字符

        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");

        // 对象和值的区别
        String s1 = new String("hello world");
        String s2 = new String("hello world");
        System.out.println(s1==s2);

        String s3 = "hello world";
        String s4 = "hello world";
        System.out.println(s3==s4);

        //布尔值拓展
        boolean flag = true;
        if (flag) {}        // 常用，好摸鱼
        if (flag == true) {}
    }
}

类型转换

强制类型转换

• 因为Java是强类型语言，所以进行运算的时候，需要用到强制类型转换。

• 在运算中，不同类型的数据需要先转换成同一种类型，然后再计算。

强制类型转换，大转小

自动类型转换，小转大

public class TypeCase {
    public static void main(String[] args) {
        //强制类型转换，大转小
        int i = 128;
        byte b = (byte) i;      //b=-128，内存溢出
        //自动类型转换，小转大
        double d = i;

        /*
        类型转换注意点：
        1.不能对布尔值进行转换
        2. 不能把对象类型转换成不相干的类型
        3. 从大类型转换成小类型的时候，用强制类型转换
        4. 转换的时候可能会内存溢出，或者精度丢失！
         */

        //精度丢失
        System.out.println((int)33.8f);     //33
        System.out.println((int)-54.33);    //-54

        //字符转换
        char c = ‘a‘;   //a在ASCII码里是96
        int i1 = c + 1; //97
        System.out.println(i1);
        System.out.println((char)i1);   //b

        //操作比较大的数时，注意类型溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
//        int total = money * years;  //-1474836480，内存溢出
//        long total2 = money * years; //还是-1474836480，原因是结果本来就是int的
        long total3 = money * (long)years; //先把一个数转换成long，然后两个变量都转换成long，就不会溢出了

    }
}

变量、常量、作用域

变量

什么是变量？

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

type varName
//变量类型 变量名

使用变量的注意点

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

变量的命名规范

• 所有的变量、方法、类名最好见名知意，即看见名字就知道什么意思。
• 类成员变量：首字母小写和驼峰原则：monthSalary，就是除了第一个单词以外，后面的单词首字母都要大写。
• 局部变量：首字母小写和驼峰原则。
• 常量：字母全部大写，可以用下划线分隔单词：MAX_VALUE
• 类名：首字母大写和驼峰原则：Person，SomePerson
• 方法名：首字母小写和驼峰原则：run()，runTime()

public class Variable {
    //类中可以定义属性和方法
    //这是属性，即变量

    //类变量
    static double salary = 2500;    //自动类型转换

    /*
    实例变量：属于对象，如果不自己初始化它，编译器会给一个默认值，
    通常数值的默认值是0或0.0，boolean类型是false，
    除了基本类型，其他类型都是null
     */
    String name;    //默认值是null
    int age;        //默认值是0

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

        /*
        局部变量：在方法里，必须声明和初始化值，作用域是这个方法，在其他方法
        用不了这个变量，方法结束局部变量也就死亡。
         */
        int i = 10;
        System.out.println(i);

        //创建对象
        Variable c = new Variable();
        System.out.println(c.name);

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

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


//    public static void main(String[] args) {
//        //声明多个变量，不建议使用，代码可读性差
//        int a,b,c;  //声明三个变量
//        int d = 1, e = 10, f = 100; //初始化三个变量
//
//        int g = 200; //基本类型
//        int h = g;   //引用类型
//
//    }

常量

什么是常量？

• 常量是初始化之后就不能再改变的值。
• 常量是一种特殊的变量，它的值被设置后在程序运行过程中是不能被改变的。
• 常量名通常字母全部大写。

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

public class Constant {

    // 修饰符，不区分先后顺序
    static final double PI = 3.14;

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

变量作用域

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

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

基本运算符

运算符

Java有下面这些运算符：

• 算术运算符：+，-*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>，<，>=，<=，==，!=，instanceof
• 逻辑运算符：&&，||，!
• 位运算符：&，|，^，~，>>，<<，>>>（了解！）
• 条件运算符：? :
• 扩展赋值运算符：+=，-=，*=，/=

运算符优先级

public class Operator {
    public static void main(String[] args) {
        //二元运算符
        int a = 10;
        int b = 20;
        int c = 46;
        int d = 57;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
//        System.out.println(a/b);    //0,结果是0.5,因为是整数除法，小数部分被丢弃
        System.out.println(a/(double)b);    //0.5

        long e = 1323213213213L;
        int f = 123;
        short g = 29;
        byte h = 2;

        System.out.println(e+f+g+h);    //long
        System.out.println(f+g+h);  //int
        System.out.println(g+h);    //int,两个都转换成int类型再计算

        //关系运算符：判断条件，返回结果是布尔值
        int i1 = 10;
        int i2 = 100;
        int i3 = 32;

        System.out.println(i3 % i1);  //32 / 10 = 3 ... 2,模运算，也叫取余

        System.out.println(i1 > i2);
        System.out.println(i1 < i2);
        System.out.println(i1 == i2);
        System.out.println(i1 != i2);

        //自增、自减运算符：++,--
        int i4 = 3;
        int i5 = i4++;  //先给i5赋值，然后i4+1
        int i6 = ++i4;  //i4先+1，再给i6赋值

        System.out.println(i4);
        System.out.println(i5);
        System.out.println(i6);

        //幂运算 2^3 2*2*2 = 8,很多运算，我们会使用一些工具类来操作！
        double pow = Math.pow(4, 2); //16.0，pow方法返回double类型
        System.out.println((int)pow);   //16，强制类型转换成int

        //与（and） 或（or） 非（取反）
        boolean j = true;
        boolean k = false;

        System.out.println("j&&k: " + (j && k)); //逻辑与运算，两个变量都为真时，结果才为真
        System.out.println("j||k: " + (j || k)); //逻辑或运算，任何一个变量为真，结果都为真
        System.out.println("!(j&&k): " + !(j&&k)); //如果是真，就变为假，如果是假，就变为真

        //短路运算
        int i7 = 3;
        boolean b1 = (i7>5) && (i7++>2);    // 第一个条件为false时，后面条件不需要再比较
        System.out.println(b1);
        System.out.println(i7);

        //位运算
        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100 // 两个位都是1的时候才为1，反之为0
        A|B = 0011 1101 // 任何一个位是1，结果都为1，两个位都是0时才为0
        A^B =
        ~B = 1111 0010 //B是1就取0，B是0就取1

        左移<<  右移>>
        2*8 = 16    2*2*2*2
        效率极高！！！
        <<      *2      因为是二进制，所以*或/ 2，如果是8进制就*或/ 8
        >>      /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);

        // += -=
        int l = 10;
        int m = 20;

        l += m; //等于l = l + m
        l -= m; //等于l = l - m

        System.out.println(l);

        //字符串连接符：+
        System.out.println("" + l + m); //1020,只要有一个字符串，就会把其他变量都转换成字符串
        System.out.println(l + m + ""); //30,这30也是字符串，但是运算顺序让l+m先计算得到30，然后30转换成字符串

        //三目运算符
        /*
        x ? y : z
        如果x==true,则结果为y，否则结构为z
         */

        int score = 80;
        String type = score > 60 ? "及格" : "不及格";
        System.out.println(type);
    }
}

包机制

什么是包机制？

• 为了更好地组织类，Java提供了包机制，用于区分类名的名称空间。
• 包机制的本质是文件夹

包的语法格式：

package pkg1.pkg2.pkg3...;

// 包语句写在源代码的第一行
package com.baidu.www;

• 通常用公司域名倒过来作为包名

怎么导包？

要想使用另一个包的类，我们需要导入这个包，使用 import语句就可以了。

import java.util.Date;	//导入util包的一个类
import java.util.*;		//导入util包的所有类和包

JavaDoc生成文档

怎么生成JavaDoc文档？

• javadoc命令是用来生成我们自己写的API文档

• javadoc的参数信息

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

在cmd上使用javadoc生成文档注释：

Java基础

原文：https://www.cnblogs.com/hongchengg/p/15048284.html