Day 004 狂神java基础第一阶段

Z时代
2024-01-10
分类：综合

java

注释

单行注释

//单行注释

多行注释

/* 多行注释多行注释 */

文档注释

/** *@文档注释 *@文档注释 */

标识符

关键字：关键字不能用来作为类名（文件名）

类名、变量名以及方法名都被称为标识符

注意

所有的标识符都应该以字母（A-Z或者a-z)、美元符号（ $ ）、或者下划线（ _ )开始

首字符之后可以是字母（A-Z或者a-z)、美元符号（ $ ）、下划线（ _ ) 或数字的任何字符组合

不能使用关键字作为变量名或者方法名

标识符是大小写敏感的

合法标识符举例：
```
age、&salary、_value、__1
```

非法标识符举例：
```
123abc、-salary、#abc
```

变量尽量使用英文命名，不用中文或者拼音

数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

安全性高，速度慢

Java为强类型语言

弱类型语言

变量的使用符合规定，

安全性低，速度快

Java的数据类型

基本类型（primitive type）
包含数值类型和Boolean（布尔）类型
数值类型：包含整数类型（1-4）、浮点类型（5、6）和字符类型在（7）
布尔值类型：占1位，值只有 true 和 false 两种

 //八大基本数据类型
//整数
int num1 = 10;//最常用
byte num2 = 20;
short num3 = 30;
long num4 = 40L;//Long类型要在数字后面加一个L
//小数：浮点数
float num5 = 50.1F;//float类型要在数字后面加一个F
double num6 = 3.141592653589793238462463;
//字符（代表一个"字“）
char name = '孙';
//字符串，String不是关键字，是一个类
String name1 = "手残的老孙";
//布尔值:是非
boolean flag = true;
//boolean flag = false;

引用类型（reference type)
包含类、接口和数组三种

注意(拓展)

进制类型

0,1//二进制
int i1 = 10;//十进制
int i2 = 010;//八进制0
int i3 = 0x10//十六进制0x

最好完全避免使用浮点数进行比较

//float  有限   离散  舍入误差   大约    接近但不等于1
//double
//银行业务不能使用浮点数
float f = 0.1f;  //0.1
double d = 1.0 / 10;  //0.1
System.out.println(f==d);  //判断 f 和 d 是否相等
						   //false
float d1 = 165413574986351674;
float d2 = d1 + 1;
System.out.println(d1==d2);  //true

所有的字符本质还是数字

Java使用Unicode表进行编码

char c1 = 'a';
char c2 = '中';
System.out.println(c1);//a
System.out.println((int) c1);//强制类型转换   97,a在表中值为97
System.out.println(c2);//中
System.out.println((int)c2);//20013
char c3 = '\u0061';
System.out.println(c3);//a

转义字符

\t /* 制表符前面的输出内容位数为8的倍数，\t将输出8个空格前面的输出内容位数不是8的倍数，\t将补足8位 */ \n //换行符

类型转换

变量内存容量高低

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

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

强制类型转换

自动类型转换

int i = 128;
byte b = (byte) i;//强制转换
double c = i;//自动转换
		/*
		强制转换：    （类型）变量名    高----->低
		自动转换：    （类型）变量名    低----->高
		*/
System.out.println(i);//128
System.out.println(b);//-128   byte最大为127， 内存溢出
System.out.println(c);//128.0

注意

不能对布尔值进行转换

不能吧对象类型转换为不相干的类型

在把高容量转换到低容量的时候，强制转换

转换的时候可能存在内存溢出，精度问题

System.out.println((int) 23.7);//23
System.out.println((int) -45.89f);//-45
System.out.println("==========================");
char c = 'a';
int d = c + 1;//char到int，低转高，自动转换
System.out.println(d);//98
System.out.println((char) d);//b   强制转换为字符型

操作比较大的数的时候，注意溢出问题

JDK7 新特性，数字之间可以用下划线分割

int money = 10_0000_0000;
System.out.println(money);//1000000000
int years = 20;
int total1 = money * years;
System.out.println(total1);//-1474836480，数据溢出
long total2 = money * years;//先计算，后转换，转换之前就存在问题了
long total3 = money * ((long) years);//先进行类型转换，后输出
System.out.println(total3);//20000000000

变量

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

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

  Type  varName [=value][{,varName[=value]}];
//数据类型  变量名  = 值；   可以使用逗号隔开来声明多个同类型变量
//不建议在一行定义多个值

变量类型及作用域

包含类变量、实例变量和局部变量三种

public class Demo08 {
    //类变量  static
    static double salary = 2500;
    //属性：变量
    //实例变量：在类里面，方法外面。从属于对象;如果不自行初始化，会变成这个类型的默认值
    //布尔值默认是false
    //除了基本类型，其余的默认值都是null
    String name;//默认为null
    int age;//默认为0
    //main方法
    public static void main(String[] args) {
        //局部变量：在一个大方法里面。必须声明和初始化
        int i = 10;
        System.out.println(i);//10
        // 变量类型 变量名字 = new Demo08;
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);//0,数值类型变量的默认值
        System.out.println(demo08.name);//null，字符或字符串类型变量的默认值
        System.out.println(salary);//2500.0
    }

注意

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

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

变量声明是一条完整的语句，因此每一个声明都必须以分号结束

常量

constant：初始化（initialize）之后不能再改变值！不会变动的值。

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final  常量名 = 值；

常量名一般使用大写字符

public class Demo09 {
    static final double PI = 3.14;
    //final static double PI = 3.14；final为修饰符，不存在先后顺序
    public static void main(String[] args) {
        System.out.println(PI);//3.14
    }
}

命名规范

所有变量、方法、类名：见名知意

类成员变量：首字母小写和驼峰原则：除了第一个单词以外，后面的单词首字母大写。monthSalary

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

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

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

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

运算符

算数运算符：+、-、*、/、%（取余，模运算）、++、--(自增自减运算符)

赋值运算符：=

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl + D ：复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println(c%a);//5,c/a=2余5
        System.out.println(a + b);//30
        System.out.println(a - b);//-10
        System.out.println(a * b);//200
        System.out.println(a / b);//0,只保留整数部分
        System.out.println(a /(double) b);//0.5
    }
}

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;
        //多个变量操作中有一个数为long，那么结果类型为long
        //若有double，则结果是double
        System.out.println(a + b + c + d);//Long
        //如果没有long，结果都为int，无论是否有int操作
        System.out.println(b + c + d);//int
        System.out.println(c + d);//int
    }
}

public class Demo04 {
    public static void main(String[] args) {
        //++  --   自增自减运算符   一元运算符
        int a = 3;
        //++在前，先自增，++在后，后自增
        int b = a++;//执行完这行代码后，先给b赋值，之后再自增
        System.out.println(a);//4
        int c = ++a;//执行这行代码前，先给a自增，再给c赋值 
        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5
        //幂运算,不可以直接使用^
        double pow = Math.pow(2, 3);
        System.out.println(pow);//8.0
    }
}

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

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：  正确，错误   布尔值
        int a = 10;
        int b = 20;
        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true 
    }
}

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

public class Demo05 {
    public static void main(String[] args) {
        //逻辑运算符，  与（and）  或（or）  非（取反）
        boolean a = true;
        boolean b = false;
        System.out.println("a && b："+(a && b));//与运算，a && b：false
        System.out.println("a || b："+(a || b));//或运算，a || b：true
        System.out.println("!(a && b)："+(!(a && b)));//非运算，!(a && b)：true
        //短路运算
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);//当&&之前为假，则直接输出，不会运行后面的代码
        System.out.println(d);//false
        System.out.println(c);//5，说明没有运行c++
    }
}

位运算符：&（与）, |（或）, ^（非）, ~（取反）, >>, <<, >>>(了解即可！！！)

public class Demo06 {
    public static void main(String[] args) {
        /*
        A=0011 1100
        B=0000 1101
        --------------------------------------
        A&B = 0000 1100  对应位全为1则为1，否则为0
        A|B = 0011 1101  对应位都为0则为0，否则为1
        A^B = 0011 0001  对应位相同为0，不同为1
        ~B  = 1111 0010
         如何计算2*8
         2*8 = 2*2*2*2
         <<位左移  *2
         >>位右移  /2
         */
        System.out.println(2<<3);//16
    }
}

条件运算符：？ :

public class Demo08 {
    public static void main(String[] args) {
        //三元运算符
        //x ? y : z
        //如果x==true，则结果为y，否则结果为z
        int score1 = 80;
        int score2 = 50;
        String type1 = score1 < 60 ? "不及格" : "及格";
        String type2 = score2 < 60 ? "不及格" : "及格";
        System.out.println(type1);//及格
        System.out.println(type2);//不及格
    }
}

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

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
        //字符串连接符   +
        //在加号两侧只要有一个是字符串类型（string），会将其他计算结果转换成字符串类型然后进行连接
        System.out.println(a + b);//30
        System.out.println("c" + a + b);//c1020
        System.out.println(a + b + "c");//30c
    }
}

运算符优先级

包机制

包的本质就是文件夹

一般利用公司域名倒置作为包名

使用import导入包

JavaDoc

用来生成自己的API文档

参数信息

@author 作者名

@version 版本号

@science 知名需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

使用IDEA生产JavaDoc文档

使用IDEA生成JavaDoc文档（2种方法）_晰烟的博客-CSDN博客_使用idea生成javadoc文档

以上是 Day 004 狂神java基础第一阶段的全部内容，来源链接： utcz.com/z/395084.html