常量
生活上大家平时接触到的不容易发生变化的数据
姓名 年龄 身高
数据： 基本 + 引用
基本：整形，浮点型，字符型，布尔型
整形：30 25 20
浮点型：1.56 95.2 3.14
字符型： 首先要加一个单引号‘’
如 '爱护' 'A' 'a'
只能表达单个字符，不能是空字符
布尔型：真假 4>3 真true 假false
引用：
在Java中有千万种
例如:欢迎您 Java ---String字符串
在文本值的左右两边分别加上双引号
表达形式：整形
小数
字符
布尔
字符串
null 引用类型值
switch case 语句
语法结构：
定义一个需要参与判定的变量switch （变量名）{
case 变量值1：
执行语句
【break】； case 变量值1：
执行语句
【break】； default：
执行语句 break；}
加载方式：
就是让变量名的值依次来匹配wsitch当中的case对应的变量值，如果匹配上，
就加载对应的变量值，如果匹配不上，就不加载
备注：如果在switch case语句中没有添加break语句，那么swith就会发生穿透现象
/*
if else 语句
中的布尔表达式可以表达有多个
中间使用逻辑运算符进行连接即可
比如闰年的判断 年份是否能整除4并且不能整除100 或者年份能够整除400
*/
Scanner类
功能： 主要就是往控制台中录入相应类型的数据
浮点整数 字符串 布尔类型 字符
该类jdk官方提供的类
使用其他类的时候，判断该类是否在同包下
如果在同包下，直接使用该类
如果不在同包下，需要引入该类对应的包
如：import java.util.Scanner;
表达方式：在package关键字的下面 import 该类的全路径
类的全路径 = 包名 + 类名 Scanner类的全路径------- java.util.Scanner
ty类的全路径--------com.ty
java程序常用包:
1 java.lang language 语法语言包，该包下的类不用导包 2 java.util java的工具包 工具类 3 java.io java的io流包 主要用于文件的读写操作 4 java.sql java的sql处理的包 针对连接数据库jdbc动作 5 java.net java的网络包 网络协议TCP UDP IP 网络通信socket Server Socket
6 java.text java文本处理包 对日期和字符串之间的转换SimpleDateFormat
7
使用： 1 需要创建该类的对象
表达语法;: Scanner scanner = new Scanner(System.in);
2 该对象中提供了很多功能 nextInt() 录入整数类型数据 nextDouble() 录入浮点类型数据 nextLine() 录入字符串类型数据 next() 录入字符串类型数据（没有换行）
备注： 1 对于Scanner类当中的nextXXXX（）方法 如果在输入时使用空格，那么系统会自动 2 对当前输入的值进行分割 如果空格有大于等于1个，那么会自动给后面的next分配他的值
Random类
功能：主要是随机一个数（整数，小数）
当前Random类不在com.ty包下面
所以也需要导包
语法格式：import java.util.Random;
使用：1 创建Random类的对象Random random = new Random();
2 使用该对象当中的功能nextInt（int bound） 随机一个[]的整数nextDouble（） 随机一个[0.0，1.0]的小数
循环结构：
程序的默认结构是顺序结构
循环结构是Java程序当中的一个很重要的结构
在有限范围内做重复动作
有三种表达形式： for语句结构 while语句结构 do-while语句结构
for语句结构：
语法结构 for(初始语句;循环语句;迭代语句){
//循环体
。。。。。}
初始语句：定义循环变量 自变量int index = 0 ;
循环进入语句： 判断当前循环是否能够继续执行index < 10
循环变量满足布尔表达式就会进入循环表达式，
如果不满足就跳出循环表达式
迭代语句： 让循环变量可以产生变化的语句 index++ 就是index变量每次递增1
index-- 就是index变量每次递减1 index+=2 就是index变量每次递增2
循环体：就是循环结构中真正执行的代码块内容
备注： for语句结构上的1 2 3 可以移动位置，不放在for里面，
只要保证for（）内有两个分号
while语句结构：
语法格式： 1 初始语句 while（2 循环进入布尔表达式）{
3 循环体 4 迭代语句}
备注： 迭代语句位置可能在循环体代码上面，也可能在循环体代码下面
sdo-while循环结构：
语法结构：1 初始语句do{
4 循环体代码 3 迭代语句 }while（2 ）
跳转语句
break语句 打断 中断 continue语句 继续
备注： break语句 除了可以使用在循环结构上，
还可以使用在switch case选择结构上 continue 只是结束本次循环，循环并不终止
循环结构也是支持嵌套表达 break语句如果使用在循环结构上，它只能结束它所在的循环结构
如果想要跳出指示的循环结构，可以使用带标签的跳转语句
语法格式：
标签（标识符）：循环结构（）{
循环结构（）{
break
continue 和break都支持该表达方式
变量：
数据类型之间的转换 类型之间是有包含关系
范围小的可以向范围大的进行转换 自动转换/隐性转换byte < short< int< long< float
范围大的向范围小的转换， 强制转换 /显示转换
备注： 1 如果范围大的变量再往范围小的类型进行转换时，
如果本身值超过了范围小的表示范围 不建议转换 因为精度会损失 2 ASCII编码表只能识别常规的字符，【0，127】
对于一些特殊的图标、图形、符号不能识别
字符0对应空字符 字符32对应空格 3 Java程序当中字符之间是可以是可以直接进行四则运算的 4 windows系统对于汉字如果是UTF-8站三个字节 g'b'k中占两个字节 5 所有编码表都支持ASCII编码表 6 char 类型的最大整数是65535，包含了一个0
运算符
赋值运算符：=
比较(关系): >大于 <小于 >=大于等于 <=小于等于 ==等于
逻辑： &逻辑与 |逻辑或 ！逻辑取非
逻辑运算符连接的是由比较运算符连接起来的表达式，结果依然是布尔类型值
逻辑与& 前后要求同时为真true 结果才为true 否则为false
逻辑或| 前后要求同时为假false 结果才为false 否则为true
取非！ 对前面的布尔表达式取相反结果
双符号运算 && || ！！
在保留自身含有之外同时具有断路作用（如果前面的布尔表达式）
备注：1 赋值运算符和算术运算符结合使用可以省略强制转换2 比较运算符当中的>= <= 只要结果有一个成立就为true
3 =赋值 ==等于4 逻辑取非 只能对！后面的布尔表达式取相反结果，前面不能出现其他内容5 逻辑取非 如果是双运算符结果不变 逻辑与& 和逻辑或| 最多只能并排使用两个
位运算符
&位与 |位或 ^位异或
三目运算符 ？：
运输语法格式：
布尔表达式 ？ 布尔表达式为真结果 ： 布尔表达式为假结果值
当不确定布尔表达式的真假时，可以使用三目运算符直接真假结果值一次性赋值
备注;
1 如果整数表达2 三目运算符的结果类型不确定，依据“？”和“：”后面放的值来判断的3 如果给三目运算符的结果值使用一个变量来接收的话，必须确定？和：后面值的类型
多元运算符：
元------涉及到有多少个操作数据
一元------ ！+ - ++ --
二元------ + - * % /
数组:
容器概念 容器主要就是把需要操作的多个数据提前存储起来
当后面需要的时候再从容器当中取出即可。
数组是一种容器 用来存储数据
数组当中的元素在数组中都有对应的位置-----索引（下标）
存储数据的时候，不能是混合类型，只能存储同一种数据类型的数据
数组容器它有规定的大小，数组容器一旦被数据创建出来只能存储它指定数量的数据
数组容器一旦规定了数量大小，那么里面必须存储数据的，而且必须存满
构建一个数量为10的数组，我就可以让该数组当中存储10个数组
假如你有九个数据，第十个位置必须给他值，哪怕是一个没有意义的值
对于数组来说，取的时候，只要没有超过数组的长度大小，程序都是允许的
长度大小是固定的
动态扩容： 如果需要存储的数据超出了该数组的长度，使用动态扩容，
首先先获取原来数组的长度，然后构建一个（原来数的长度的大小+超过的个数）的数组
之后依次取出原来对应位置上的数组元素存储到新数组当中，之后把新元素存储到新数组的末尾位置
再之后把已经储存好的新数组赋值给原数组变量，就完成了动态扩容
使用：1
创建数组的两种方式：动态创建，静态创建 1.1 动态创建 数组元素数据类型[] 数组名称 =new 数组元素数据类型[长度]
创建一个int类型的数组int[] arr = new int[3];
如果你定义的是int整形 存储的元素值为0
double 0.0
char 空格boolean null
1.2 静态创建语法格式： 数组元素数据类型[] 数组名称 = {元素值1，元素值2，元素值3......}
如果你填写了5个元素值，那么该数组的长度为5
如果你填写了7个元素值，那么该数组的长度为7
1.3 静态和动态结合 new 数组元素数据类型[]{元素值1，元素值2，元素值3..} 省略数组名称创建数组
2 存储（修改）和取出元素操作
语法格式： 数组名称[索引下标值]
备注：1索引下标值只能是整形，不能是浮点型 2索引下标取值范围：[0，数组名称.length-1] 0对应第一个位置 1对应第二个位置
3 计算
3.1 计算数组容器当中元素的最大值
实现思路： 依次从数组当中取出元素和当前的最大值进行比较大
值留下经过n次比较之后，得出当前数组当中的最大值
3.2计算数组当中元素的最小值实现思路:类似于求最大值
3.3 计算数组当中元素的总和值 累加值 3.4 计算数组当中元素的平均值 总和值÷数组元素的个数4 数组的增删改查 crud开发工程师c----增加元素c creat
r----检索/查找r retrieve
u----修改元素u update
d----删除元素 d delete
定义数组格式
数组元素的数据类型[] 数组名称 = new 数组元素数据类型[长度]；
自定义的数组其实是Java当中的引用类型Array的衍生品
从中获取了一个length类型
数组它也是一种引用数据类型int[] double[] String[]
数组当中存储的元素的类型也可以是引用数据类型
动态创建
数组元素的数据类型[] 数组名称 = new 数组元素类型[]；
静态创建
数组元素的数据类型[] 数组名称 = {元素值1，元素值2，......}
静态创建方式 必须在一行语句上完成， 不能拆分两行语句来完成
数组赋值
数组工具类Arrays
常用功能：sort（array）对当前传入的数组进行升序排序binarySearch（array，value）查找指定元素value在指定数组array
当中储存位置（下标值）----前提条件是有序的
该功能有一个结果值，是一个int类型值，需要有一个变量去接收toString（array） 对当前数组转换成一个字符串类型的值，
这个值的内容就是数组当中的每一个元素值
该功能也有一个结果值，是一个String类型值，需要有一个变量去接收
使用功能：
语法格式： Arrays.功能名称（）；//如果（）里面有信息，
就传入想要的信息值，如果没有，就不传入
动态扩容
int[] arr ={19,20,21};
int ar =arr.length;
int[] new_arr =new int[ar+1];
new_arr[1-1] =arr[1-1];
new_arr[2-1] =arr[2-1];
new_arr[3-1]=arr[3-1];
new_arr[4-1]=18;
arr =new_arr;
Arrays.toString(arr);
String ar1 =Arrays.toString(arr);
System.out.println(ar1);
二维数组：
二维数组也可以理解成一个一维数组
语法格式：
动态方式： 数组元素数据类型[][] 数组名称= new int[m][n];
m-----二维数组的长度 n-----二维数组中元素的长度 可以为空
静态创建： 数组元素数据类型[][] 数组名称 ={{元素值1}，{元素值2}};
修改和取出元素：
数组名称[下标值]-----从该二维数组当中取出的对应的一维数组
数组名称[m][n]-----从该二维数组当中取出m对应的一维数组的n元素
面向对象oop
java语言是一种面向对象编程的开发语言
面向对象------类class
类： 物以类聚人以群分
我们会把一些相似的或者相同的一些功能或者事物，集中性储存在同一个地方（class）
还有一些相似或者相同的特征的事物集中在一起 还可以把它理解成一种模式，模板 class类它是我们Java程序当中的最小的组成单元或者单位（类文件当中）
对象：对象就是通过类实例化构建出来的一个个具体的事物
通过对象来调用类当中定义的那些相似或者相同的功能，或者是那些相似或者
相同的特征，来完成功能开发或者需求开发
构建类的对象语法格式 ：
类名 变量名（对象名） new 类名（）；
在类当中主要的内容是功能，函数-----方法method function函数
比如说计算指定范围内前n项的和 功能一
比如说计算指定范围内有多少水仙花数 功能二
方法定义的语法格式：
四要素： 修饰符 返回值类型 方法名称 方法参数
修饰符 返回值类型 方法名称（参数数据类型 参数名称1，参数数据类型参数名称2.......）
方法右边跟的{}------方法体----该方法的作用域
注意事项：
类当中的方法它定义的位置，应该在类的里面，main方法的外面
方法内部不能重复声明定义其他方法----嵌套
方法它只能是一种并列关系
修饰符：
修饰限定方法使用 访问权限控制的 静态的static 最终的final....
返回值类型：
该方法执行完之后，需不需要给方法的调用者返回一个结果值。
如果需要返回的，定义对应的返回值的数据类型 如果不需要返回的，
那么我们可以定义空参数 使用关键字void
返回值的数据类型：基本+引用（String，数组）+void
备注：
void它只能作为方法返回值的数据类型，不能作为其他事物（对象）
的数据类型，只能出现在方法声明的格式上
方法名称： 它就是一个标识符
方法参数： 参数列表
参数的数据类型：基本+引用
参数的名称：它也是一个标识符 见名知意
方法类型格式：四种 1 无返回值 无参数 2 有返回值 无参数 3 无返回值 有参数 4 有返回值 有参数
在启动类程序时，程序只会加载main方法当中的信息，
不会加载main以外的信息，如果想要加载main方法以外的信息，需要
进行引用声明，把main外的信息在main方法中声明一些
声明格式:
方法名称（参数值1，参数值2，...）；
如果该方法有返回值,一般情况下需要接收方法的返回值
定义一个变量来接收 方法名称（参数值1，参数值2，...）.var 回车让系统生成
变量数据类型 变量名称 =（参数值1，参数值2，...）；
方法重载：
如果在程序当中定义的方法功能是一样的，只是因为方法当中的阐述列表当中
参数类型不同，Java系统允许这多个方法共有一个名字
减少开发者记忆类功能名字的作用
影响方法重载的因素是 参数列表（参数个数，参数顺序，参数类型）
只要有三者有一个不一致就不行。
修饰符，返回值类型不会影响方法重载，
方法的返回值
如果方法有返回值,我们是一定要添加返回语句
返回语句格式： return 返回的具体值； 返回值必须要和方法声明格式上的保持一致
return关键字
它的主要作用是作为方法的返回来使用的
返回类型:
空返回
表达形式： return；
当方法声明的格式确定是没有返回值的（void）
使用return； 表达形式是用来结束方法程序的
带值返回
当方法声明的格式上确定是有定义的返回值类型（不是void），
使用return具体的返回值；给当前方法一个指定值，同时他也
有结束方法程序的作用
类当中的属性
相当于类的特征 描述该类的特征信息
在语法上类似于我们之前学习的变量
属性等价于成员变量，全局变量，实例变量
属性定义的语法格式：
属性数据类型 属性名称[ =属性值]； [= 属性值]；是一种可选操作
调用类当中的数据语法格式：
需要借助对象：
创建对象的语法格式： 类名称 对象名称 = new 类名（）；
备注：
类当中的属性，如果开发者没有手动赋值，Java程序会自动给类赋值
完成初始化，根据属性定义的数据类型：int 0
double 0.0
char 空格boolean false
引用类型null
属性主要是用来描述对象特征
类的定义
[public] class 类名{
定义属性 实例变量，全局变量，全局变量，成员变量 一个意思
属性数据类型 属性名称 =[属性值]；//...
//定义成员方法/实例方法/普通方法/非静态方法 一个意思
方法定义四要素： [修饰符] 返回值类型 方法名称1（参数数据类型 参数名称1，参数数据类型 参数名称2.。。。）{
} 具体业务逻辑 [修饰符] 返回值类型 方法名称2（参数数据类型 参数名称1，参数数据类型 参数名称2.。。。）{
} 具体业务逻辑
局部变量和全局变量的不同之处： 1，定义的位置不同：局部变量是定义局部范围内（方法内），
全局变量是定义在类中，方法外 2.初始化不同，对于局部变量来说，局部变量未赋值不能直接
使用（局部变量不会自动初始化），全局变量如果没有赋值，系
统会自动赋一个默认值 3，生命周期：一个对象在程序当中（内存当中）从生到死的过程
局部变量一般定义方法内，从该方法被调用开始，到该方法从栈中
弹出时消亡，
全局变量从它所在的对象被创建时开始存在，到该对象从堆当中被
垃圾回收器（gc）回收时消亡 4，存储的位置不同：局部变量大多存储在（方法栈）栈中，
全局变量一般存储在堆当中。
封装特性：
1.隐藏把功能的一些实现细节隐藏掉，对外提供功能接口，对第三方开发者
或者使用用户来说，比较方便，大大提高了后续开发的效率， 2.可以提高代码的复用性，
广义封装：
对程序当中任何高频重复性的代码进行提取的动作，都认为是一种封装
工具类的概念
工具方法（通用方法）
狭义封装：
对类当中的属性进行封装
使用关键字private
提供对应的Getter和Setter方法 Getter方法是用来在外类中获取该类当中对应的属性值
固定写法： public 属性对应的数据类型 get属性名称[首字母大小]（）{
return；}
Setter方法是用来在外类当中设置该类中对应的属性值
固定写法： public void set属性名称[首字母大写]（属性对应的数据类型 属性名称）{
this.属性名称 = 属性名称；}
构造方法：
作用：主要是用来创建类的对象（完成类的实例化）
次要作用：
在完成类的实例化的时候，对类当中定义的私有属性进行初始化（赋值）
构造方法定义的语法格式： public 当前类名（属性的数据类型 属性名称1，属性的数据类型 属性名称2....）{
如果方法上面有参数，需要使用this关键字 this.属性名称1 =属性名称1； this.属性名称2 =属性名称2； this.属性名称3 =属性名称3；........
}
构造方法的特点：
1 构造方法声明格式上没有具体的返回值类型 不可使用void
（是因为该方法的返回值类型是确定的，返回值类型唯一） 2 构造方法名称需要和当前类名完全保持一致，大小写完全相同
（假如你类名写的不规范如首字母小写，那么构造器方法也要小写 3 构造方法是支持方法重载（构造方法可以在类当中定义多个） 4 构造方法修饰符一旦使用private修饰，意味着该类不能直接
在外类当中进行实例化，一般情况下需要该类当中调用其他方法
完成实例化 5 构造方法如果在该类当中没有定义过，不影响开发着进行该类的
实例化（系统会添加一个默认的构造方法），一旦你定义了其他的
构造方法那么系统会删除添加的默认构造方法--空参构造，需要开
发者手动添加this关键字：
该关键字是用在方法当中，该方法不能是一个static修饰的方法
比如main方法就是一个static修饰的关键字
意义：
当方法格式上有参数传递时，参数名称和类当中的属性名称重名了
按照Java当中的就近原则，优先使用方法声明上参数，单是对于开
发者来说使用的是类当中定义的属性，就需要使用this关键字来声
明它是属性，而不是一个参数
Getter方法
是用来在外类中获取该类当中对应的属性值
固定写法： public 属性对应的数据类型 get属性名称[首字母大小]（）{
return；}
Setter方法
是用来在外类当中设置该类中对应的属性值
固定写法：public void set属性名称[首字母大写]（属性对应的数据类型 属性名称）{
this.属性名称 = 属性名称；
Java Bean
创建一个类的时候，这个类如果主要是用来存储数据的
一般需要按照以下方式进行定义：
类的定义需要是公共的 public class 类名{}
类的属性必须是私有的 private 属性数据类型 属性名称；
类当中必须提供Getter和Setter方法 ALT+insert 快捷键生成
类当中必须有该方法 public 类名（）{}
以下信息可以非标准的
类当中还需提供该方法 public 类名（声明全部的属性参数信息） {需要对类当中所以的属性都进行赋值 this.属性名称=属性名称；}
该类还需要实现 public class 类名implements Serializable{}
该类改需要提供 public String toString（）{return 属性名称“”+属性名称}
如按照以上方法定义出来的类，就叫做JavaBean
Bean---(bean)描述Java的人家组件模型（Enterprise Java Bean） Java模型类 model 类 实体类------不参与业务逻辑，只存储数据
继承：
继承是Java当中的第二个重要特性：extends关键字----扩展
对相同的代码进行抽取----工具类的概念---封装
让多个有重复性的类产生关联性 继承关系
把重复性的代码放到共有类当中，让其他类去继承这个共有类
特点：
一个class子类只能有一个直接父类，
通过继承子类可以获取到父类当中所有的成员信息
变量特点：
1 当父类的成员变量是私有的，子类虽然有父类的成员变量，但是是不能直接使用的。只有当父类的成员变量非私有，子类才可以直接使用 2 如果子类定义了相同的成员变量，那么子类在使
用时，优先使用的是自己定义的成员变量 3 如果子类定义了相同的成员变量，那么如果想要 使用父类的成员变量，使用关键字super来调用
父类当中的成员变量
继承关系的成员方法特点： 1 如果父类的成员方法是私有的，那么子类是不能
使用的，如果父类的成员方法非私有，那么子类可以 2 如果子类定义了相同的成员方法，这种叫方法重写
（覆盖），改变原来内容，重新定义，子类调用该方
法时，优先调用的是子类重写后的方法，如果该方法
没有，那么它会层层往父类当中去查找。 3 使用idea工具在进行方法重写提示时，idea工具会
自动添加一个注解@Override，表明修饰的方法是来源
于它的父类 4 如果子类想要使用父类当中的方法，需要使用super
关键字来进行调用。 5 如果你既想要保留父类原有的功能，又想要进行功能
扩展，那么可以在方法重写内容首先执行super.（父类）方法
备注：
如果在进行方法重写时，你修改父类的方法参数
（参数个数，类型，顺序），系统会判定这是一个新
方法，此时在进行方法重载，而非方法重写
如果在进行方法重写时，你修改的不是方法参数，而是
方法的修饰符和返回值类型，此时程序判定这是一个相
同方法，同一个方法是不能定义的，此时是一个非法操
作
使用继承语法格式： class 类名（子类） extends 类名（父类）{}
superclass父类 subclass子类
假设a类有吃喝拉撒睡 ，b类当中也有吃喝拉撒睡----删除a类当中
的吃喝拉撒睡睡功能，让a类 extends b类
假设A类当中有吃喝学习工作 B类当中有吃喝抽烟赌博，创建一个共有类
删除A类当中的吃喝功能，删除B类当中的吃喝功能
让A类extends C类； 让B类extends C类；*/
//被public修饰的类名必须和所在的类文件名称保持一致
//一个类文件当中只能有一个被public修饰的类
凡是被static修饰的----static context
静态信息只能在静态的环境中使用，如果想要
在静态环境中使用非静态信息只能通过对象来
使用，对于非静态信息一般使用在非静态环境
中，如果使用静态信息可以直接使用
方法重写
在子类进行方法重写时，必须保证子类声明的方法格
式与父类定义的方法格式一致，方法重写是通过方法
名称来进行匹配的
如果子类在方法上添加不同的方法参数，系统会判定
当前这个方法是一个新方法，此时在进行方法重载
0人点赞
410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
