java基础语法-修饰符-运算符

基本语法

Java是从C++语言改进重新设计的。
能被java.exe成功运行的java class文件必须有main（）方法。

注释

介绍：①注释是在程序的指定位置添加的说明性信息；②注释不参与程序运行，仅起到说明作用。
注释分类：

说明	格式	idea快捷键
单行注释	//注释信息	Ctrl + /
多行注释	/* 注释信息*/	Ctrl + Shift + /
文档注释	/** 注释信息*/	在需要注释的位置输入/** 按下enter即可实现

关键字

概述

介绍：
被java语言赋予特定含义的单词。

关键字特点：
①字母全部小写；②文本编辑器中关键字有特殊颜色；

包 package

概念：
其实就是文件夹。
主要用来对类和接口进行分类；当开发java程序时，可能编写成百上千的类，因此有必要对类和接口进行分类。

作用：
对类进行分类管理

定义格式：

package 包名；（多级包用.分开）

带包类的编译执行过程：
手动创建包：

• ①使用记事本在E盘下创建java文件，写导包命令 package com.itheima126； 类名是HelloWorld
• ②编译执行：使用javac HelloWorld即可
• ③运行程序：必须在E盘下重建com文件夹》在其中再创建itheima126文件夹，再把HelloWorld.class文件（编译.java文件产生的文件）放入itheima126文件夹下
• ④在cmd命令提示窗中 执行java com.itheima126.HelloWorld 即可执行程序

自动创建包：

• ①在java文件中书写 创建包的命令package 包1.包2.包3…
• ②编译.java文件，使用命令 javac -d . 文件名.java 即可实现包的创建
• ③运行class文件，使用命令 java 包1.包2.包3.文件名

备注2022/8/11
package语句只能出现在最上面、属于该类的第一行（不含注释）；且只能出现一次；
提供Java存储数据能力的包是java.sql。

import导包

作用：
使用不同包下的类，需要写类的全路径，为了简化包的操作，java提供了导包。
import语句用来提供一个合理的路径，使得编译器可以找到某个类。

格式：
import 包名；

备注2022/8/11
同一个类中import 可以出现1次或多次；
import语句 应该出现在package语句之后，类定义语句之前；

常见类的导包

导包	常见类
java.lang	String类、Math类、Integer类、System和Thread
java.util	Stack类、Scanner类、Set、Map
java.awt 抽象窗口工具集	List类

this关键字

概述

this修饰的变量用于指代成员变量

• 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量。(this.age = 成员变量；age = 方法形参)

// 成员变量
private int age;
// 成员方法
public void method(int age){
	this.age = age;
}

• 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量。

方法中使用this的原因
解决局部变量隐藏成员变量的问题。

this代表什么
代表所在类的对象引用。
理解：方法被哪个对象调用，this就代表哪个对象。

案例：学生类

// 111
public class Student1 {
    //定义成员变量
    private String name;
    private int age;

    //定义get/set方法
    public String getName() {
        return name;
    }

    //引入this
    //为了代码的可读性，起名字一般需要有明确的含义。下边这个n不能明确显示出这是一个name变量。
//    public void setName(String n) {
//        name = n;
//    }
/*    public void setName(String name){
        name = name;
    }*/
    //当设置成为上述这种形式的时候，方法测试类出现错误，setName不可以实现赋值。
    //原因：在setName方法中，name = name的赋值只可以看到局部变量name，不能看到成员变量name。
//要想实现此功能，需要使用this关键字
    public void setName(String name){
        this.name = name;
        //此时的this.name表示的是成员变量name，name表示的是局部变量name
    }
    public int getAge() {
        return age;
    }

    public void setAge(int a) {
        age = a;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

案例：学生测试类

public class StudentDemo1 {
    public static void main(String[] args) {
        //创建对象
        Student1 stu = new Student1();

        //set方法设置成员变量
        stu.setName("汪苏泷");
        stu.setAge(33);

        //调用成员方法
        stu.show();//汪苏泷,33
    }
}

this引入图示：

this内存原理

理解：方法被哪个对象调用，那个方法里面的this就是哪个对象。

常量

介绍：
在程序运行过程中，取值不会改变的量。

常量分类：

名称	介绍	案例	说明
字符串常量	用双引号括起来的内容	“HelloWorld”
整数常量	不带小数的数字	666；-88	可以是正数、负数
小数常量	带小数的数字	13.14；-5.21	可以是正数、负数
字符常量	用单引号括起来的内容	‘A’;‘0’;‘我’	字符常量可以是字符、数字、汉字
布尔常量	布尔值，表示真假	只有两个值：true、false
空常量	一个特殊的值，空值	值是：null	不能直接输出，通过System.out对象的println方法输出

变量

概述

介绍：
变量就是在程序运行的过程中，其值可以发生改变的量。
本质上讲，变量是内存中的一小块区域。

分类
变量可以分为：成员变量、局部变量；成员变量又可以分为静态成员变量、实例变量。

变量定义格式：

数据类型 变量名 = 变量值；
//解释：
数据类型也就是对变量的限制
变量名也就是暂存位置
变量值也就是暂存位置存储的内容

变量的使用：取值和修改值。

取值：
	变量名
修改值：
	变量名 = 变量值 ；

变量使用的注意事项

• 一个类的main函数里中的变量名不能重复；
• 未赋初值的变量不能被使用；
• long类型变量定义的时候，为了防止整数过大，后面要加L
  解释：由于整型默认为int类型，定义long l = 100000000000的时候会报整数太大的错误（12位），因为虽然这样书写了，但是编译的时候会默认= 右边的数值为int类型（-2³¹—+2³¹，即-2147483648~+2147483648（10位数字）），上述值已经超过int的类型的表示范围。要想不报错，就需要在数值后面加L，书写为long l = 100000000000L；
• float类型变量定义的时候，为了防止类型不兼容，后面要加F；
  解释：定义float f = 13.14，出现错误（不兼容的类型，从double转换到float可能会有损失，因为小数默认类型是double类型）。要想避免错误的出现，需要在13.14后面加F；
• Java编程时，要尽量少用公共变量；

成员变量（实例变量）

成员变量（实例变量）：类内方法外的变量

局部变量

局部变量：方法中的变量

静态变量

静态变量：static修饰的变量，也就是类变量。
备注2022/8/12
静态成员变量的定义发生在static代码块以及其赋值之前。

成员变量和局部变量区别

区别	成员变量	局部变量
编写位置不同	类内方法外	方法内或方法声明上
内存位置不同	堆内存	栈内存
生命周期不同	随着对象的存在而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同	有默认的初始值	没有默认的初始值，必须先定义，赋值，才能使用

理解：
①类中位置不同。
局部变量在方法内或方法申明上，方法申明上指的是：定义方法时形参的位置，也就是括号中的变量。

静态变量和实例变量的区别

数据类型

计算机存储单元：
计算机储存设备的最小信息单元叫“位（bit）”，又称为“比特位”，通常用小写字母‘b’表示。
计算机中最小的存储单元叫“字节（byte）”，通常用大写字符“B”表示，字节是由连续的8个位组成。
常见的存储单元：1B（字节）=8bit；1KB = 1024B；1MB = 1024KB；1GB = 1024MB；1TB = 1024GB；
Java是强类型语言，对于每一种数据都必须给出明确的数据类型，不同的数据类型也分配了不同的内存空间。

注意

2022/4/14
java的基本数据类型没有Int类型的，只有int类型，两者的区别在于首字母i的大小写
var i = 3.14；是支持的，在jdk10中，var表示模糊定义
java中没有const关键字
2022/6/24
java基本数据类型默认值 int类型 = 0 char类型 = 0对应的字符 float类型 = 0.0 double类型 = 0.0 java中String类型 = null
2022/7/16
关于科学计数法，只能是double使用。 double a = 440.1e2
2022/8/12
0.6333的数据类型是double，小数的默认类型是double类型、Float和Double是float和double的基本数据类型的包装类

类型转换

分类两种：
自动类型转换、强制类型转换

自动类型转换：把一个表示数据范围小的数值或者变量 赋值 给另一个表示数据范围大的变量。赋值数值范围（小到大）

解释：byte可以赋值给short、int、long、float、double类型。byte不能赋值给char类型变量。

强制类型转换：把一个表示数据范围大的数值或者变量 赋值 给另一个表示数据范围小的变量。赋值数据范围（大到小）
格式：

目标数据类型 变量名 = （目标数据类型）值或者变量

解释：①数据类型的图示是上图倒过来的顺序②强制类型转换不建议使用，因为会造成数据丢失

赋值时，编译器能够自动完成缩放类型转换

T t = S;
① S为byte、short、char 或者 int;
② T为byte、short 或者 char类型;
也就是 表达式S的值，在类型T的取值范围之内。

备注2022/8/11
不能通过编译的是哪个？

A String s = "join" + 3 (√ 前者String类型 后者是Integer类型 两者强转为String类型)
B int a = "join" + 3 (x 前者String类型 后者是Integer类型 两者不能强转为int类型)
C int a = 'a' + 5 (√ 前者char类型 后者是int类型 自动类型转换 int类型可行)
D float f = 5 + 5.5 (√ 前者int 后者float 自动类型转换 float类型)

不能通过编译的是哪个？

A byte a = 1 (√ 前者byte类型 后者是Integer类型 编译器自动完成缩放 )
B short b = 100 (√ 前者short类型 后者是Integer类型 编译器自动完成缩放)
C int c = 'a' (√ 前者int类型 后者是char类型 自动类型转换 char - int)
D float f = 5 + 5.5 (√ 前者int 后者float 自动类型转换 float类型)

标识符

介绍：
它是给类、方法、变量等起名字的符号。

注意事项：
①由数字、字母、下划线和美元符$组成；
②不能以数字开头；
③不能是关键字；
④区分大小写。

常见命名约定：

名称	命名规则	使用场景
小驼峰命名法	①标识符是一个单词的时候，首字母小写 ②标识符由多个单词组成的时候，第一个单词首字母小写，其他单词的首字母大写	方法、变量
大驼峰命名法	①标识符是一个单词的时候，首字母大写 ②标识符由多个单词组成的时候，每个单词的首字母都大写	类

特殊转义字符

符号	含义
\n	换行
\r	回车
\f	换页
\b	退格
\s	空格
\t	制表符
‘’	双引号
\	反斜杠
’	单引号
\ddd	八进制字符
\uxxxx	十六进制字符

修饰符

权限修饰符

有四类：private、默认、protected、public。

说明	访问情况
父类中有上述四种权限修饰符修饰的方法	main方法可以访问private、默认、protected、public修饰的方法
与父类同一个包 子类继承于父类 无关类（与父类没有关系）	main方法可以访问默认、protected、public修饰的方法
不同包 子类继承于父类	main方法可以访问protected、public修饰的方法
不同包 无关类（与父类没有关系）	main方法可以访问public修饰的方法

扩展2022/5/3

• protected
  允许把某些东西深深地藏起来，但同时允许访问衍生类的成员。（衍生类=子类）
  本身是私有的，但可由这个类继承的任何东西 或者 同一个包内的其他东西访问。
• private
  随时都是私有的，任何人不得访问。

备注：2022/8/11
java的四种权限修饰符：public > protected > default > private
子类继承父类 涉及到的方法重写，子类方法的访问权限不能小于父类方法的访问权限。

private修饰符

概述

• 介绍：
  是一个权限修饰符；
  可以修饰成员（成员变量和成员方法）；

• 作用：
  是保护成员不被别的类使用，被private修饰的成员只能在本类中才能被访问；

• 针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作。
  提供$\underline{get变量名()}$方法，用于获取成员变量的值，方法用public修饰；
  提供$\underline{set变量名（参数）}$方法，用于设置成员变量的值，方法用public修饰。
  注意：变量名要注意首字符大写。

• 注意：
  private修饰的成员方法仅可以被同一类的所有成员方法访问。

案例：测试类

// 110
//学生测试类
public class Student1Demo {
    public static void main(String[] args){
        //创建对象
        Student1 stu = new Student1();
        //通过对象给成员变量赋值
        stu.name = "aa";
        //设置类的成员变量为private权限时，就不能够通过对象.属性来给成员变量赋值。
        
       // stu.age = 20;
        //通过对象.属性直接访问对象的属性会存在数据安全隐患。
        //具体问题是：年龄是没有负数的，且也不可能超过120，但是在直接操作的时候，可能会手误书写成负数。
        stu.getAge();
        stu.setAge(-30);//输入的年龄有误

        //调用成员方法
        stu.show();//aa， 0 输出的是成员变量age的默认值0
    }
}

案例：学生类

// 110
//学生类
public class Student1 {
    //成员变量
    String name;
    //为了解决对象直接访问属性可能造成的数据安全隐患问题，将age设置为private权限。
   // int age;
    private int age;
    //设置类的成员变量为private权限时，就不可通过创建对象，对象.属性来给成员变量赋值。
    //访问类中private成员变量的方式是创建方法：
    // 获取成员变量值——get变量名（）；设置成员变量的值——set变量名（参数）；变量名的首字母需要大写
    public int getAge(){
       return age;
    }
    public void setAge(int a){
        //为了避免造成对成员变量赋值时产生的数据安全隐患，比如age年龄不可能有负数，也不可能特别大，所以要在方法中添加条件判断。
        if(a < 0 || a > 120){
            System.out.println("输入的年龄有误");
        }else{
            age = a;
        }
    }

    //成员方法
    public void show(){
        System.out.println(name + "， " + age);
    }
}

代码重点图示：

2022/6/29
为了解决直接通过对象.属性 访问成员变量可能会造成的数据安全问题，使用private修饰成员变量；

private关键字使用

标准的编写：
把成员变量用private修饰；
提供对应的getXxx（）/getXxx（）方法。

代码：学生测试类

//学生测试类
public class StudentDemo {
    public static void main(String[] args){
        //创建对象
        Student stu = new Student();

        //set方法设置成员变量
        stu.setName("汪苏泷");
        stu.setAge(33);

        //调用成员方法
        // 输出的是两个变量之间使用逗号分隔。
        stu.show();//汪苏泷,33

        //也可以使用任意符号分隔
        System.out.println(stu.getName() + "---" + stu.getAge());//汪苏泷---33
        System.out.println(stu.getName() + "***" + stu.getAge());//汪苏泷***33
    }
}

代码：学生类

// 只有博客中有
//学生类
public class Student {
    //定义成员变量
    private String name;
    private int age;

    //定义get/set方法
    public String getName() {
        return name;
    }

    public void setName(String n) {
        name = n;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int a) {
        age = a;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

状态修饰符final和static

修饰符名	final（最终态）	static（静态）
修饰内容	表示最终的意思 可以修饰成员方法、成员变量、类	表示静态的意思 可以修饰成员方法、成员变量
成员方法 成员变量 类	修饰成员方法：表明该方法是最终方法，不能被重写 修饰成员变量：表示该变量是常量，不能被赋值 修饰类：表示该类是最终类，不能被继承	被类的所有对象共享（判断是否使用静态关键字的条件） 可以通过类名调用 或者 对象名调用（推荐使用类名调用）
修饰局部变量	修饰基本类型：final修饰指的是基本类型的数据值不能发生改变 final int age = 10 ; 修饰引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容可以发生改变 final Student st = new Student();
访问特点		非静态的成员方法： 能访问静态的成员变量、成员方法；能访问非静态的成员变量、成员方法 静态的成员方法： 能访问静态的成员变量、成员方法

注意：

• final 和 static final 的区别：
  final修饰的引用数据类型内容可以修改，但是引用地址不能修改；
  static final修饰变量，因为static修饰所以装载时已经进行初始化了，而不是每次创建对象都进行初始化，所以内容不能修改。

案例：final

// 123
public class Student {
    public int age = 20;
}
public class Demo {
    public static void main(String[] args) {
        int age = 30;
//        final int age = 30;//当局部变量 基本类型 使用final修饰时，基本类型的变量的数值就不能进行修改了。
        age = 100;
        System.out.println(age);

        System.out.println("-------------");
//        Student s = new Student();
        final Student s = new Student();
        //final修饰引用数据类型的局部变量，要去引用数据类型的地址值不变，而地址对应的内容是可以变化的。
        s.age = 200;
        System.out.println(s.age);
    }
}

abstract

备注2022/8/11
①abstract可以用来修饰类和方法，类（抽象类）、方法（抽象方法）。
抽象类可以没有抽象方法，但抽象方法所属类一定是抽象类。
static和abstract不能同时存在。
②abstract类不能被实例化。（抽象方法必须通过抽象类创建子类，进而创建对象）
③抽象类和抽象方法不能被final修饰。（抽象类只有创建子类，抽象方法才能被实现，而final修饰的类不能拥有子类）
④abstract类的子类必须实现其父类的所有abstract方法。× （abstract的子类不实现父类的abstact方法的话 就得子类本身是abstact修饰才可以。）

运算符

运算符 = 对常量或者变量进行操作的符号
表达式 = 用运算符把常量或者变量连接起来符合java语法的式子
不同运算符连接的表达式体现的是不同类型的表达式。

算术运算符

符号	作用
+	实现数据相加
-	实现数据相减
*	实现数据相乘
/	实现数据相除，得到是商
%	实现数据取余，得到是余数

理解：

2022/6/24
整数相除只能得到整数，要想得到小数，必须有浮点数的参与。 也就是说 有浮点数的参与，除法可以得到含有小数的结果，例如：3/2.0 = 1.5

关系运算符

有六种：

符号	作用
==	判是否相等
!=	判是否不相等
>	判是否大于
<	判是否小于
>=	判是否大于等于
<=	判是否小于等于

理解：
关系运算符的输出结果的类型是boolean类型，只有两个结果true和false。

逻辑运算符

有四种。

符号	作用
&	逻辑与，有false则false
|	逻辑或，有true则true
^	逻辑异或，相同为false，不同为true
!	逻辑非，！false = true，！true = false

备注：
markdown实现逻辑或 | 书写是（&#124英文状态分号）书写。

短路逻辑运算符

有两种。

符号	作用
&&	短路与，有false则false，但是有短路效果
||	短路或，有true则true，但是有短路效果

逻辑运算符与短路逻辑运算符区别

• ①
  逻辑与&，无论左边真假，右边都要执行；
  短路与&&，左边为真，右边执行；左边为假，右边不执行；
• ②
  逻辑或|，无论左边真假，右边都要执行；
  短路或||，左边为假，右边执行；左边为真，右边不执行。

案例：

最常用的逻辑运算符： 短路&&，短路||，逻辑非！

位运算符

java定义了运算符，应用于整数类型（int）、长整型（long）、短整型（short）、字符型（char）和字节型（byte）等类型。位运算符作用在所有的位上，并且按位运算。

符号	含义
&	对应位 全1则1，有0则0
|	对应位 全0则0，有1则1
^	相对应位值相同，结果为0；否这结果为1
~	取反操作
>>	按位右移操作符，左侧的操作数 按位右移 右操作数 指定的位数
<<	按位左移操作符，左侧的操作数 按位左移 右操作数 指定的位数
>>>	按位右移补零操作符。左侧的操作数 按位右移 右操作数 指定的位数 ，移动得到的空位以零填充

运算符有优先级

运算符	介绍	执行顺序
后缀	() [] .(点操作符)	左到右
一元	！ ~ ++ – +（一元运算符）-（一元运算符）	右到左
乘性	* / %	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
关系	> >= < <=	左到右
相等	== !=	左到右
按位与	&	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	||	左到右
条件	? :	右到左
赋值	= += -= *= /= %= >>= <<= &= ^= !=	右到左
逗号	，	左到右

字符的“+”操作

介绍：
字符与数字进行计算的时候，会拿字符在计算机底层对应的数值来进行计算。
常用字符在计算机底层对应的数值介绍如下：
A = 65，A-Z是连续的；
a = 97，a-z是连续的；
0 = 48，0-9是连续的。
理解：
①算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。（执行自动类型转换）
②提升规则：byte、short、char类型会被提升到int类型；整个表达式的类型自动提升到表达式中最高等级操作数同样的类型；等级顺序：byte、short、char》int》long》float》double

字符串的“+”操作

介绍：
①当“+”操作中出现字符串时，“+”是字符串连接符，而不是算术运算符；
②当连续进行“+”操作时，从左到右逐个执行，“+”两侧没有字字符串，则表示算术运算符；
案例：

“i have a dream” + 999 》 结果i have a dream999
1 + 99 + “年奋斗史”》结果100年奋斗史
// 很好体现了从左到右逐个执行，因为左侧的式子是 1+99 这时+是算术运算符。

赋值运算符

符号	作用
=	赋值，把右边的赋值给左边
+=	加后赋值，把左边和右边的数据做加法操作，结果赋值给左边
-=	减后赋值，把左边和右边的数据做减法操作，结果赋值给左边
*=	乘后赋值，把左边和右边的数据做乘法操作，结果赋值给左边
/=	除后赋值，把左边和右边的数据做除法操作，结果赋值给左边
%=	取余后赋值，把左边和右边的数据做取余操作，结果赋值给左边

理解：
扩展的赋值运算符底层包含了强制类型转换。

案例：

案例说明：
扩展的赋值运算符（a += b）和普通的合并运算符（a = a + b），
使用扩展的赋值运算符，下述两种情况都不会报错。
使用普通的合并运算符，当参与运算的变量是int类型和整型（默认int类型）时，不会报错；参数运算的是short类型和整型（默认int类型），会报错。

自增自减运算符

介绍：
（++）自增，变量的值加1
（- -）自减，变量的值减1

解释：
①++ 和 – 可以放在变量前也可以放在变量后。
②++i 或 i++ 单独使用效果一样。（Int i = 10，++i 和 i++ 结果都是11）
③参与操作使用 效果会不一样。如果放在变量后，先拿变量参与运算，后拿变量做++或–；如果放在变量前，先拿变量做++或–，后拿变量参与操作。


常见用法是：
单独使用。

注意xhj：

2022/4/24
当b = b++的时候，会先将b赋值给b，然后在自加1

package offer2.Test424;

public class Test1 {
    public static void main(String[] args) {
        int a = 0;
        a = ++a;
        int b = 0;
        b = b++;
        System.out.println("a:" + a);
        System.out.println("b:" + b);
        // a:1
        //b:0
    }
}

三元运算符

格式：

关系表达式？表达式1：表达式2；

计算规则：
①计算关系表达式的值；
②关系表达式值为true，表达式1的值就是最终运算结果；
③关系表达式值为false，表达式2的值就是最终运算结果。

案例：