day03 Java基础
文章目录
- Java基础语法
-
- 1. 注释、标识符、关键字
-
- 注释
- 标识符
- 关键字
- 2. 数据类型
-
- 基本类型(primitive type)
- 引用类型(reference type)
- 3. 类型转换
-
- 强制类型转换
- 自动类型转换
- 4. 变量、常量
-
- 变量
- 常量
- 5. 运算符
-
- 算术运算符
-
- 加减乘除 + - * /
- 自增自减 ++ --
- 取余 %
- 关系运算符
- 逻辑运算符
- 位运算符
- 条件运算符
- 扩展赋值运算符
- 6. 包机制、JavaDoc
-
- 包机制
- JavaDoc生成文档
Java基础语法
1. 注释、标识符、关键字
注释
注释并不会被执行，是给我们写代码的人看的
书写注释是一个非常好的习惯
Java中的注释有三种：
- 单行注释
- 多行注释
- 文档注释
public class HelloWorld {
public static void main(String[] args) {
//单行注释：只能注释一行文字 //
//输出一个Hello,World!
System.out.println("Hello,World!"); //hello
//多行注释：可以注释一段文字 /* 注释 */
/*
多行注释
多行注释
多行注释
*/
//JavaDoc:文档注释 /** */
/**
* @Description HelloWorld
* @Author mollzz
*/
}
}
有趣的代码注释
盘点一下全网最有趣的代码注释
标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
注意点：
- 所有标识符都应该以字母（A-Z或a-z），美元符（$），或者下划线（_）开始
- 首字符之后可以是字母（A-Z或a-z），美元符（$），下划线（_）或数字的任何组合
- 不能使用关键字作为变量名或方法名
- 标识符是大小写敏感的
- 可以使用中文命名，但是一般不建议这样去使用。也不建议使用拼音
- 合法标识符举例：age、$salary、_value、__1_value
- 非法标识符举例：123abc、-salary、#abc
关键字
Java中的关键字有哪些？「Java中53个关键字的意义及使用方法」_java关键字-CSDN博客
【JAVA】JAVA关键字-CSDN博客
2. 数据类型
强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
弱类型语言
Java的数据类型分为两大类：
- 基本类型
- 引用类型(reference type)
基本类型(primitive type)
-
数值类型
整数类型
-
byte占1个字节范围：-128~127
-
short占2个字节范围：-32768~32767
-
int占4个字节范围：-2147483648~2147483647
-
long占8个字节范围：-9223372036854775808~9223372036854775807
浮点类型
- float占4个字节
- double占8个字节
字符类型
- char占2个字节
-
-
boolean类型
占1位，其值只有true和false两个
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类型区分
double num6=3.1415926;
//字符
char name='中';
//字符串 String不是关键字，是类
//String namea="mollzz";
//布尔值:是非/真假
boolean flag=true;
//boolean flag=false;
}
}
什么是字节：
-
位（bit）：是计算机内部数据存储的最小单位，11001100是一个八位二进制数。
-
字节(byte)：是计算机中数据处理的基本单位，习惯上用大写B来表示。
-
1B（byte,字节）= 8bit（位）
-
字符：是指计算机中使用的字母、数字、字和符号
-
1bit 表示 1位
-
1Byte 表示一个字节 1B = 8b
-
1024B = 1KB
-
1024M = 1G
引用类型(reference type)
- 类
- 接口
- 数组
3. 类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
低 ———————————————————————————— 高
byte,short,char ——> int ——> long ——> float ——> double
运算中，不同类型的数据先转化为同一类型，然后进行运算。
强制类型转换
自动类型转换
public class Demo05 {
public static void main(String[] args) {
int i=128;
byte b=(byte) i;//内存溢出
//强制转换 (类型)变量名 高——低
//自动转换 低——高
System.out.println(i);
System.out.println(b);
/*
注意点：
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换为低容量的时候，强制转换
4.转换的时候可能存在内存溢出，或者精度问题！
*/
System.out.println("__________________");
System.out.println((int)23.7);//23
System.out.println((int)-45.89f);//-45
System.out.println("__________________");
char c='a';
int d=c+1;
System.out.println(d);//98
System.out.println((char)d);//b
}
}
4. 变量、常量
变量
变量是什么：就是可以变化的量！
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域。
type varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值; 可以使用逗号隔开来声明多个类型变量。
注意事项：
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型
- 变量名必须是合法的表示符
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
变量的命名规范：
- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastname——>lastName
- 局部变量：首字母小写和驼峰原则
- 常量大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man，GoodMan
- 方法名：首字母小写和驼峰原则：run()，runRun()
变量作用域：
- 类变量
- 实例变量
- 局部变量
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);
System.out.println(demo08.age);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
常量
常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不要允许被改变。
final 常量名=值;
final double PI=3.14;
常量名一般使用大写字符。
5. 运算符
Java语言支持如下运算符：
- 算术运算符：+，-，*，/，%，++，–
- 赋值运算符：=
- 关系运算符：>，<，>=，<=，==，!= instance of
- 逻辑运算符 &&，||，!
- 位运算符 &，|，^，~，>>，<<，>>>（了解！！！）
- 条件运算符 ？：
- 扩展赋值运算符：+=，-=，*=，/=
Java常用运算符及其优先级_java运算顺序-CSDN博客
算术运算符
加减乘除 + - * /
package operator;
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(a+b);//30
System.out.println(a-b);//-10
System.out.println(a*b);//200
System.out.println(a/(double)b);//0.5
}
}
package operator;
public class Demo02 {
public static void main(String[] args) {
long a=10000000L;
int b=100;
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型
}
}
自增自减 ++ –
package operator;
public class Demo04 {
public static void main(String[] args) {
//++ 自增 -- 自减 （一元运算符）
int a=3;
int b=a++; //a++ 先赋值后计算 执行这段代码前，先给b赋值，再自增
int c=++a; //++a 先计算后赋值 执行这段代码前，先自增，再给c赋值
System.out.println(a);//5
System.out.println(b);//3
System.out.println(c);//5
}
}
取余 %
package operator;
public class Demo03 {
public static void main(String[] args) {
int a=10;
int b=21;
//取余，模运算
System.out.println(b%a);//1
}
}
关系运算符
package operator;
public class Demo03 {
public static void main(String[] args) {
//关系运算符返回的结果：正确，错误 布尔值
int a=10;
int b=20;
int c=21;
//取余，模运算
System.out.println(c%a);//1
System.out.println(a>b);//false
System.out.println(a<b);//true
System.out.println(a==b);//false
System.out.println(a!=b);//true
}
}
逻辑运算符
&& 逻辑与运算：两个变量都为真，结果才为true
|| 逻辑或运算：两个变量中有一个为真，则结果就为true
! 逻辑非运算：如果是真，则变为假；如果是假，则变为真
package operator;
//逻辑运算符
public class Demo05 {
public static void main(String[] args) {
// 与（and） 或（or） 非（取反）
boolean a=true;
boolean b=false;
// && 逻辑与运算：两个变量都为真，结果才为true
// || 逻辑或运算：两个变量中有一个为真，则结果就为true
// ! 逻辑非运算：如果是真，则变为假；如果是假，则变为真
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(c);
System.out.println(d);
}
}
位运算符
按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、>>右移、<<左移
除按位取反（~）运算符是单目运算符，其余均为双目运算符
优先级由高到低：~、&、^、|
package operator;
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
>> 右移 /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); //16
}
}
条件运算符
x ? y : z
如果x==true,则结果为y,否则结果为z
package operator;
//三元运算符
public class Demo08 {
public static void main(String[] args) {
// x ? y : z
//如果x==true,则结果为y,否则结果为z
int score=80;
String type=score<60?"不及格":"及格"; //必须掌握
System.out.println(type); //及格
}
}
扩展赋值运算符
+=、-=、*=、/=
package 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);//10
//字符串连接符 +
System.out.println(a+b);//30
System.out.println(""+a+b);//1020
System.out.println(a+b+"");//30
}
}
6. 包机制、JavaDoc
包机制
为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：
package pkg1[.pkg2[.pkg3...]];
例：
package com.mollzz.operator;
一般利用公司域名倒置作为包名
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能
import package1[.package2...].(classname|*);
JavaDoc生成文档
javadoc命令是用来生成自己API文档的
jdk帮助文档：Overview (Java Platform SE 8 ) (oracle.com)
参数信息：
- @author 作者名
- @version 版本名
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
package com.mollzz.base;
/**
* @author mollzz
* @version 1.0
* @since 1.8
*/
public class doc {
String name;
/**
* @author mollzz
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception{
return name;
}
}
命令行页面生成文档：
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
Microsoft Windows [版本 10.0.19045.3930]
(c) Microsoft Corporation。保留所有权利。
D:\桌面\MarkDownStudy\TestProject\JavaSE\JavaSE\grammar\src\com\mollzz\base>javadoc -encoding UTF-8 -charset UTF-8 Doc.java