Java基础知识

目录

注释、标识符、关键字

1.注释

2.关键字

 3.标识符

数据类型

1.数据类型

整数

浮点型

字符

字符串

布尔型

2.进制问题

3.转移字符

类型转换

1.强制转换 （由高到低）

2.自动转换（由低到高）

变量与常量

1.变量

2.常量

 运算符

JavaDoc

​​​​​​

• 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。
• 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
• 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

• 注释、标识符、关键字

1.注释

单行注释：//

多行注释：/*注释内容*/

文档注释：/**     */

//单行注释

/*可以注释一段文字*/

/**
 * @xiaoerzi 666
 * @的时刻 665
 */

2.关键字

常见关键字（不能作为变量名）：

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
	default	默认
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 Java 实现）
	new	新,创建
	static	静态
	strictfp	严格,精准
	synchronized	线程,同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供 switch 选择
	continue	继续
	default	默认
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用

 3.标识符

• 标识符由数字（0~9）和字母（A~Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）。
• 标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。

• 数据类型

1.数据类型

整数

        int num1=10;
        short num2=55;
        byte num3=30;
        long num4=30l;//加l；

浮点型

double num5=3.23;
float num6=3.23f;//加f；

  float与double的区别：

有限  离散 舍入误差  大约 接近但不等于（尽量避免比较大小）

        float a1=0.1f;
        double a2=1.0/10;
        System.out.println(a1==a2);    false
        System.out.println(a1);        0.1
        System.out.println(a2);        0.1
        float b1=1214543213213543f;
        float b2=b1+1;
        System.out.println(b1==b2);    true 
        System.out.println(b1);        1.2145432E15
        System.out.println(b2);        1.2145432E15

字符

char name='y';

字符串

String nam="yqy";

布尔型

        boolean flag1=true;
        boolean flag2=false;

2.进制问题

二进制：0b    十进制     八进制：0    十六进制：0x

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

3.转移字符

\t 制表
\n换行

• 类型转换

转换顺序表（低—>高）

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

1.强制转换 （由高到低）

（类型）+原数据   

2.自动转换（由低到高）

        int i=128;
        byte b=(byte) i;//内存溢出
        System.out.println(b);
        //自动转换   低到高
        double c=i;
        System.out.println(c);

 输出结果：

-128
128.0

ps：

1.不能对布尔类型进行转换
2.不能把对象转为不相干的类型
3.转换时可能会出现内存溢出问题、精度问题

溢出问题：

        int m=1000000000;
        int n=300;
        int o1=m*n;
        System.out.println(o1);//溢出，输出复数
        long o2=m*n;
        System.out.println(o2);//溢出
        //先运行m*n，在强制转换为long，m*n已经是错的
        long o3=m*((long)n);//先把其中一个转换成long
        //int * long=long
        System.out.println(o3);

 输出结果

-647710720
-647710720
300000000000

• 变量与常量

1.变量

变量基本要素：变量名、变量类型、作用域

变量名命名规范

• 所有变量、方法、类名：简明知意（禁用拼音）
• 类成员变量：首字母小写和驼峰原则（lastName）
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线（MAX_SHW）
• 类名：首字母大写和驼峰原则
• 方法名：首字母小写和驼峰原则

参数默认值：一般为0，null  布尔值的默认值为false

实例变量：在类中定义，无需初始化

类变量：static（加static可以直接输出，与实例有区别）

局部变量：作用在某一方法内

public class bianliang {
    //实例变量，在类内从属于对象
    //无需初始化
    String name;
    int age;
    //类变量 static
    static double salary=2500;
    //加static可以直接输出，与实例有区别

    //main 方法
    public static void main(String[] args) {
        //基本要素：变量名、变量类型、作用域
        int a=10;
        double b=1.2;
        char c='d';
        String d="sasjk";
        //****************************
        //以上局部变量只作用于main函数里，不能在add里面用
        bianliang bian=new bianliang();
        System.out.println(bian.age);//0
        System.out.println(bian.name);//null
        //默认值 0  null  布尔值默认false

        //类变量  static
        System.out.println(salary);
    }
    //其他方法
    public void add(){
    }
}

输出结果：

0
null
2500.0

2.常量

定义：final  类型  常量名=值

public class changliang {
    //定义：final 类型 常量名=值
    static final double PI=3.14;
    final static  double PI1=3.14;
    //修饰符顺序无所谓
    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(PI1);
    }
}

•  运算符

1. 算术运算符：+ - * / % ++ --
2. 赋值运算符：=
3. 关系运算符：>  < ==  !=
4. 逻辑运算符：&&  ||  ！
5. 位运算：&   |   ^   ~   >>   <<  
6. 条件运算符：？：

public class YSF {
    public static void main(String[] args) {
    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);//整数相除为int型，取整
        System.out.println(a/((double)b));
        System.out.println(a>b);//关系运算符返回布尔值 true/false
        System.out.println(c%b);

        //字符串连接符
        System.out.println(""+a+b);//识别为字符串，则拼接1020
        System.out.println(a+b+"");//识别为整形则相加，30
        System.out.println(a+=b);//a=a+b;
        System.out.println("*******************");
        // ++自增  --自减
        int m=a++;//先给m赋值，再自增
        int n=++a;//先自增，再给n赋值
        System.out.println(a);
        System.out.println(n);
        System.out.println(m);
        System.out.println(n);
        //*******************************
        //幂运算  (函数)
        double p=Math.pow(2,3);//2^3=8
        System.out.println(p);
        System.out.println("**********************");
        //*****************************************
        //逻辑操作符  与 或 非
        boolean z=true;
        boolean x=false;
        System.out.println("z&&x:"+(z&&x));
        System.out.println("z||x:"+(z||x));
        System.out.println("!(z&&x):"+!(z&&x));
        System.out.println("*********************");
        //***********************
        //位运算
        /*
            A=0011 1100
            B=0000 1101
            -------------
                 0011 1100
                 **** ****
                 0000 1101
            A&B= 0000 1100
            --------------
                 0011 1100
                 ++++ ++++
                 0000 1101
            A|B= 0011 1101
            --------------
                 0011 1100
                 |||| ||||
                 0000 1101
            A^B= 0011 0001  //相同为0，不同为1
            ~B=  1111 0010 取反
            <<左移  *2
            >>右移  /2
         */
        System.out.println(2<<3);
    }
}

输出：

30
-10
200
0
0.5
false
5
1020
30
30
*******************
32
32
30
32
8.0
********************
z&&x:false
z||x:true
!(z&&x):true
********************
16

• JavaDoc

//: POI/ExportConfig
/** Excel导出项配置
 * @author Mr zhang
 * @version 1.0
 * @since 1.8
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD })
public @interface ExportConfig {

	/**
	 * @return 表头显示名(如：id字段显示为"编号") 默认为字段名
	 */
	String value() default "field";

	/**
	 * @return 单元格宽度 默认-1(自动计算列宽)
	 */
	short width() default -1;

	/**
	 * 将单元格值进行转换后再导出：

	 * 目前支持以下几种场景：

	 * 1. 固定的数值转换为字符串值（如：1代表男，2代表女）

	 * 表达式: "s:1=男,2=女"

	 * 
	 * 2. 数值对应的值需要查询数据库才能进行映射(实现com.haohuo.util.poi.convert.ExportConvert接口)

	 * 
	 * @return 默认不启用
	 */
	String convert() default "";

	/**
	 * @return 当前单元格的字体颜色 (默认 HSSFColor.BLACK.index)
	 */
	short color() default HSSFColor.BLACK.index;

	/**
	 * 将单元格的值替换为当前配置的值：

	 * 应用场景: 

	 * 密码字段导出为："******"
	 * 
	 * @return 默认true
	 */
	String replace() default "";
}///:~  

• Java修饰符

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

• public : 对所有类可见。使用对象：类、接口、变量、方法

• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

访问控制

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

受保护的访问修饰符-protected

• 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；

• 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。

final 修饰符

final 变量

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

final 方法

父类中的 final 方法可以被子类继承，但是不能被子类重写。

声明 final 方法的主要目的是防止该方法的内容被修改。

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。