JavaDoc

java基础

注释

平时我们写代码的时候，在代码较少的时候，能够轻易看懂自己写的东西，但是当代码复杂起来，我们就需要注释了

书写注释是很好的习惯

平时写代码一定要加注释

java中注释有三种

1. 单行注释 //注释一行文字

2. 多行注释 /* */注释一段文字

3. 文档注释 /** 可以加参数

   ​ *

   ​ */

标识符

关键字：

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

标识符注意点

1. 所有的标识符都应以字母，美元符，或者下划线开头
2. 首字母之后可以是任意字母任意组合
3. 不能以关键字作为变量名或者方法名
4. 标识符是大小写敏感的
5. 可以使用拼音或者中文命名，但十分不建议

数据类型

1. 强类型语言，要求变量严格符合规定，所有变量必须先定义后才能使用（java）

2. 弱类型语言（Java不是）

3. 数据分为两类

   1. 基本类型（primitive type）

      1. 数值类型

         1. 整数类型

            byte占一个字节范围

            short占两个字节范围

            int占4个字节范围（最常用）

            long占8字节内容（要在数字后面加L)

         2. 浮点类型（浮点数，小数）

            float占4个字节（加一个F）

            double占8个字节

         3. 字符类型：char占两个字节

      2. boolean类型：占1位其值只有true和false两个

   2. 引用类型（reference type）

      1. 类
      2. 接口
      3. 数组

​ 类型 字节数 二进制位数
​ byte （字节型） 1 8
​ short（短整型） char （字符型） 2 16
​ int （整型） float （单精度浮点数） 4 32
​ long（长整型） double（双精度浮点数） 8 64

进制

int i1 = 10;
int i2 = 010;//八进制加0
int i3 = 0x10;//十六进制加0x
//二进制0b
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);

所有字符的本质还是数字

char c1 = '中'；
System.out.println((int)c1);//强制转换

编码，Unicode 2字节 0-65536

//转义字符
// \t制表符
// \n换行
// \u转译

//布尔值拓展
boolean flag = true;
if(flag==true){//==true可省略
    
}

类型转换

Java是强类型语言,所以有些你算的时候需要进行类型转换

低-------------------------------------->高

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

public class Demo_a{
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;//内存溢出
        
        //强制转换  形式：(类型)变量名  高--低

        System.out.println(i);//结果128
        System.out.println(b);//结果-128(超出了内存范围)
    }
}

public class Demo_b{
    public static void main(String[] args) {
        int i = 128;
        double b = i;
       
        //自动转换     低--高
        
        System.out.println(i);//结果是128
        System.out.println(b);//结果是128.0
    }
}

public class Demo_c{
    public static void main(String[] args) {
        System.out.println((int)23.7);//结果是23（内存溢出）
        System.out.println((int)-45.89f);//结果是-45（精度问题）
        char c = 'a';//Unicode编码
        int d = c+1;
        System.out.println(d);//98
        System.out.println((char)d);//b，强制转换为字符
    }
/*
注意点
1. 不能把布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，用强制转换
4. 转换的时候可能存在内存溢出或者精度的问题
*/
}

public class Demo_d{
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        int money = 1_000_000_000； //可以在数字之间加"_","-"不会被输出
        int years = 20;
        int total =money*years;
        System.out.println(total);//-1474836480
        long total_ =money*years;
        System.out.println(total_);//-1474836480,转换之前已经存在问题了，程序先将int算出，再转换成为long
        long total__ = money*((long)years);
        System.out.println(total__);//成功输出200亿
        // long 后缀尽量用L，而不用l
    }

变量

1. 变量，是可以变化的量
2. java是一种强类型语言，每一个变量都必须声明其类型
3. Java变量是程序中最基本的储存单元，其要素包括变量名，变量类型和作用域
4. 注意事项
   1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型
   2. 变量名必须是合法的标识符
   3. 变量声明是一条完整的语句，因此每一个声明必须以分号结束

public class Demo_e {
    public static void main(String[] args) {
        //int a,b,c
        int a = 1;
        int b = 2;
        int c =3;
        String name = "老睿";
        char x = 'x';
        double pi = 3.14;
    }
}

变量作用域

类变量

实例变量

局部变量

public class Demo_f{
    //属性：变量

    //类变量static
    static double salary = 5000;//5000 的默认是int，自动转换

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

    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i = 10;

        System.out.println(i);

        //变量类型 变量名字 = new Demo_f();

        Demo_f demo_f = new Demo_f();

        System.out.println(demo_f.age);
        System.out.println(demo_f.name);

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

    }
    //其他方法
    public void add(){
    }
}

常量

初始化之后不能够再次改变得值，不会变动的值

常量是一种特殊的变量，它的值被设定后，在程序运行过程中不会被改变

final 常量名
final double PI=3.14

public class Demo_g {

    //static 和 final 是修饰符，不区分先后顺序

    static final double PI = 3.14;

    final static double IP = 3.14;

    public static void main(String[] args) {

        System.out.println(PI);
        System.out.println(IP);

    }
}

变量的命名规范

1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则：monthSalary,除了第一个单词意外，后面的单词都大写
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则：Man,GoodMan
6. 方法名：首字母小写和驼峰原则：run(),runRun()

运算符

算数运算符：+，-，*,/,%(取余数）,++,--

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

        //二元运算符
        //Crrl+D:复制当前行到下一行
        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/b);//有误差舍为零
        System.out.println(a/(double)b);
    }
}
二元运算符

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

        System.out.println(a+b+c+d);//long,如果操作中有一个数为long，那么结果类型也为long
        //如果操作中有一个数为double，那么结果类型也为double
        System.out.println(b+c+d);//int，如果没有long，结果都为int！！！
        System.out.println(c+d);//int
        System.out.println((double)c+d);//int

    }
}
二元运算符

public class Demo_c {
    public static void main(String[] args) {
        //关系运算符返回的结果：True/False   (布尔值)

        int a = 10;
        int b = 20;

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);//判段是否等于
        System.out.println(a!=b);


        int c = 21;

        System.out.println(c%a);//取余(模运算)  21/10 =2...1
    }
}
二元运算符

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

        int b = a++;//这一句执行完的下一句才会给a加一，就是说要先给b赋值，再给a加一
        //a = a+1;
        System.out.println(a);
        //a = a+1;
        int c = ++a;//执行这行代码之前，先自增，再给c赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);


        //幂运算 2^3 = 2*2*2    很多运算，我们会使用工具去运算，“Math."
        double pow = Math.pow(2, 3);
        System.out.println(pow);

    }
}
一元运算符

public class Demo_e {
    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));//如果是真，则为假，如果是假则变为真

    }

}

赋值运算符：=

关系运算符：>,<,>=,<=,==(等于)，!=,instanceof

逻辑运算符：&&、||,! //与或非

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

2<<3  ==> 16
    0000 0000    0
    0000 0001    1
    0000 0010    2
    0000 0011    3
    0000 0100    4
    0000 1000    8
    0001 0000    16
    往左移一位就是*2  <<
    往右移一位就是/2  >>
    eg：2*8 = 16 


    

public class Demo_f {
    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);

        //字符串连接 +  String
        System.out.println(a+b);
        System.out.println(""+a+b);//字符串在前，整个变成字符串
        System.out.println(a+b+"");//字符串在后面，正常运算
    }
}

public class Demo_g {
    public static void main(String[] args) {
        // x ? y : z
        //如果x==true,则结果为y,否则为z

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

}

条件运算符：？

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

包机制

为了跟好地组织类，java提供了包机制，用于区别类名的命名空间

语法格式：

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

一般用公司域名倒置作为包名com.baidu.www com.baike.www

为了能够使用某一个包的成员，我们要在java程序中明确导入该包。使用"import"语句可以完成这个功能。

import package1[.package2......].(classname|*);//.*导入这个包下所有的类符。

Java Dos

用来自己生成自己的API文档

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况