南山网站建设方案书,wordpress 图片 筛选 插件,网络营销seo教程,铜陵app网站做营销招聘信息标识符与命名规范
标识符
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
技巧#xff1a;凡是自己可以起名字的地方都叫标识符。
定义合法标识符规则
由26个英文字母大小写#xff0c;0-9 #xff0c;_或$组成
数字不可以开头。
不可以使用关键字和…标识符与命名规范
标识符
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
技巧凡是自己可以起名字的地方都叫标识符。
定义合法标识符规则
由26个英文字母大小写0-9 _或$组成
数字不可以开头。
不可以使用关键字和保留字但能包含关键字和保留字。
Java中严格区分大小写长度无限制。
标识符不能包含空格。
练习miles, Test, a, --a, 4#R, $4, #44, apps, class, public, int, x, y, radius
Java中的名称命名规范
包名
多单词组成时所有字母都小写xxxyyyzzz
类名、接口名
多单词组成时所有单词的首字母大写XxxYyyZzz
变量名、方法名
多单词组成时第一个单词首字母小写第二个单词开始每个
单词首字母大写xxxYyyZzz
常量名
所有字母都大写。多单词时每个单词用下划线连接XXX_YYY_ZZZ
注意1在起名字时为了提高阅读性要尽量有意义“见名知意”。
注意2java采用unicode字符集因此标识符也可以使用汉字声明但是不建议使用。
使用变量注意事项
Java中每个变量必须先声明后使用(否则会编译失败)
使用变量名来访问这块区域的数据
变量的作用域其定义所在的一对{ }内
变量只有在其作用域内才有效
同一个作用域内不能定义重名的变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9h5cKvT2-1631633254213)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210806223011477.png)]
变量的分类(按数据类型)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qfRqe4m8-1631633254217)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210806223440586.png)]
各种变量类型与其表示范围
整数类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fjhQdfkI-1631633254219)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210806224402195.png)]
浮点类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h0XyG1eN-1631633254223)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210806233006012.png)]
字符类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Y0IeBmA-1631633254226)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210806233809741.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vWCkQmEg-1631633254227)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210806235329165.png)]
布尔类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BZM5gFHo-1631633254229)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807003246851.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5J5Uwc2c-1631633254230)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807003827294.png)]
类型转换(整型常量默认为int浮点型常量默认为double)
自动类型提升
容量小的类型自动转换为容量大的数据类型。
数据类型按容量大小排序为
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jkMgSI8L-1631633254231)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807105500719.png)]
有多种类型的数据混合运算时系统首先自动将所有数据转换成容量最大的那种数据类型然后再进行计算。
byte,short,char之间不会相互转换他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时()基本数据类型的值将自动转化为字符串(String)类型。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TGvD6jwR-1631633254232)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807104645682.png)]
强制类型转换
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GTIxjMi8-1631633254234)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807105930762.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CkD6AGc8-1631633254235)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807110123009.png)]
String类型
char VS String
char类型初始值不能为空String类型可以
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xatV54Yh-1631633254237)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807111532248.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nFANGpLn-1631633254238)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807112052894.png)]
判断对错
String str1 4; //判断对错no
进制与进制之间的转换
进制简介
所有数字在计算机底层都以二进制形式存在。
对于整数有四种表示方式
二进制(binary)0,1 满2进1.以0b或0B开头。
十进制(decimal)0-9 满10进1。
八进制(octal)0-7 满8进1. 以数字0开头表示。
十六进制(hex)0-9及A-F满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
如0x21AF 1 0X21B0
原码反码补码
Java整数常量默认是int类型当用二进制定义整数时其第32位是符号位
当是long类型时二进制默认占64位第64位是符号位
二进制的整数有如下三种形式
原码直接将一个数值换成二进制数。最高位是符号位
负数的反码是对原码按位取反只是最高位符号位确定为1。
负数的补码其反码加1。
计算机以二进制补码的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码1
为什么要使用原码、反码、补码表示形式呢
计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是
人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正
数等于加上一个负数, 即: 1-1 1 (-1) 0 , 所以机器可以只有加法而没有
减法, 这样计算机运算的设计就更简单了。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OkLp9zpX-1631633254239)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807153816331.png)]
进制之间的转换
十进制 二进制互转
二进制转成十进制
乘以2的幂数
十进制转成二进制
除以2取余数
二进制 八进制互转
二进制 十六进制互转
十进制 八进制互转
十进制 十六进制互转
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yjwIkPut-1631633254241)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807160005119.png)]
运算符
%
结果符号与被求模数符号一致
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WcVPxTt9-1631633254242)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807161024883.png)] 连续赋值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e4ijl2Ps-1631633254244)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807162215233.png)]
ab不一定等于aab
说明不会改变本身变量的数据类型与–运算符一样
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xfWcrHJd-1631633254245)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807162511388.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vZnBaxNt-1631633254246)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807162500966.png)]
题目一
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D1LVFXW0-1631633254248)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812152013957.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kGB32mbs-1631633254249)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807163032623.png)] VS
—逻辑与
| —逻辑或
—逻辑非 —短路与
|| —短路或
^ —逻辑异或
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qonAovDJ-1631633254250)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807163528688.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qGEvY4zO-1631633254251)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807163710050.png)] VS
才是乘以2操作
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cp0pNTUC-1631633254252)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807171719389.png)]
?表达式1:表达式2
表达式1和表达式2为同种类型
if-else(就近原则)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GQBtIgse-1631633254253)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807221849193.png)]
题目一
两种写法不一样
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4z7NdVEW-1631633254254)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210817193226382.png)]
switch表达式中的类型
switch(表 达式)中表达式的值必须是下述几种类型之一
byteshortcharint枚举(jdk 5.0)String (jdk 7.0)
case子句中的值必须是常量不能是变量名或不确定的表达式值(
1.boolean类型不能参与运算
2.不和if-else长得像
)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pIrhD6Ro-1631633254255)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807234410830.png)]
同一个switch语句所有case子句中的常量值互不相同
break语句用来在执行完一个case分支后使程序跳出switch语句块如果没有break程序会顺序执行到switch结尾
default子句是可任选的。同时位置也是灵活的。当没有匹配的case时执行default
不能为longdoublefloatboolean类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SEhqrDKs-1631633254256)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807234200206.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6vhIWhCk-1631633254257)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210807234226996.png)]
for循环
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TGrjEiCx-1631633254258)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808002244011.png)]
变量初始化
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hggSLNFa-1631633254259)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808095614892.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TVEgk920-1631633254261)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808095703540.png)]
质数
质数素数只能被1和它本身整除的自然数。–从2开始到这个数-1结束为止都不能被这个数本身整除。
最小的质数是2
算法时间测试
输出也会占用大量时间
break VS continue
使用范围 循环中使用的作用(不同点) 相同点 break: 循环结构中 结束当前循环 关键字后面不能声明执行语句
continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sEYlAL7d-1631633254262)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808130632010.png)]
return
return并非专门用于结束循环的它的功能是结束一个方法。当一个方法执行到一个return语句时这个方法将被结束。
与break和continue不同的是return直接结束整个方法不管这个return处于多少层循环之内
数组
数组本身是引用数据类型而数组中的元素可以是任何数据类型包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定就不能修改。
初始化
一维数组
数组一旦初始化完成其长度就确定了 int[] ids;//声明//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行ids new int[]{1001,1002,1003,1004};//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行String[] names new String[5];//错误的写法
// int[] arr1 new int[];
// int[5] arr2 new int[5];
// int[] arr3 new int[3]{1,2,3};//也是正确的写法int[] arr4 {1,2,3,4,5};//类型推断
二维数组 //静态初始化int[][] arr1 new int[][]{{1,2,3},{4,5},{6,7,8}};//动态初始化1String[][] arr2 new String[3][2];//动态初始化2String[][] arr3 new String[3][];//错误的情况
// String[][] arr4 new String[][4];
// String[4][3] arr5 new String[][];
// int[][] arr6 new int[4][3]{{1,2,3},{4,5},{6,7,8}};//也是正确的写法int[] arr4[] new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};int[] arr5[] {{1,2,3},{4,5},{6,7,8}};默认值
数组元素是整型0 数组元素是浮点型0.0 数组元素是char型0或’\u0000’而非’0’ 数组元素是boolean型false 数组元素是引用数据类型null
内存结构
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMfuau4q-1631633254263)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808174124694.png)]
一维数组
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IHZOHmdS-1631633254264)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808174422787.png)]
二维数组(本质都是一维数组 )
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gtDzImcz-1631633254265)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808221618348.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sqo9ERlc-1631633254266)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808230411452.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OaineDir-1631633254268)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808230639828.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UcI6qykR-1631633254271)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808230702599.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-11ThQZ6D-1631633254272)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808230715723.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XOnmxyp3-1631633254273)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808231153843.png)]
赋值规则
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MZFbnKOY-1631633254274)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210808233404679.png)]
杨辉三角
package com.wdl.day07;/*** 创建人 wdl* 创建时间 2021/8/8* 描述*/
public class YangHuiTest {public static void main(String[] args) {int[][] yanghui new int[10][];for (int i 0; i yanghui.length; i) {yanghui[i] new int[i 1];yanghui[i][0] 1;yanghui[i][i] 1;for (int j 1; j i; j) {yanghui[i][j] yanghui[i - 1][j] yanghui[i - 1][j - 1];}}for (int[] ints : yanghui) {for (int anInt : ints) {System.out.print(anInt );}System.out.println();}}
}二分查找
package com.wdl.day07;/*** 创建人 wdl* 创建时间 2021/8/9* 描述*/
public class ArrayTest2 {public static void main(String[] args) {int[] arr {-2, -1, 0, 5, 6, 9, 55};int head0;int endarr.length-1;int dest1505;boolean isFlagtrue;while (head end) {int middle(headend)/2;if (dest1arr[middle]){System.out.println(找到了指定的元素位置为middle);isFlagfalse;break;}else if (dest1arr[middle]){head middle1;}if (dest1arr[middle]){endmiddle-1;}}if (isFlag){System.out.println(很遗憾没有找到的啦);}}
}冒泡排序
package com.wdl.day07;import java.util.Arrays;/*** 创建人 wdl* 创建时间 2021/8/9* 描述*/
public class BubbleSortTest {public static void main(String[] args) {int[] arr {4, 0, 2, 5, 4, 8, 7, 8, -2, -9, 66};for (int i 0; i arr.length-1; i) {for (int j 0; j arr.length - 1 - i; j) {if(arr[j]arr[j1]){int temparr[j];arr[j]arr[j1];arr[j1]temp;}}}System.out.println(Arrays.toString(arr));}
}类的成员组成
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fynWYFM3-1631633254275)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210809233842204.png)]
对象的创建和使用(内存解析)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M9eXqKJv-1631633254275)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210810152553749.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IJODZXtw-1631633254276)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210810153310042.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JhfATAVt-1631633254277)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210811163349777.png)]
属性VS局部变量
类中属性的使用属性成员变量 vs 局部变量1.相同点1.1 定义变量的格式数据类型 变量名 变量值1.2 先声明后使用1.3 变量都有其对应的作用域2.不同点2.1 在类中声明的位置的不同属性直接定义在类的一对{}内局部变量声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量2.2 关于权限修饰符的不同属性可以在声明属性时指明其权限使用权限修饰符。常用的权限修饰符private、public、缺省、protected ---封装性目前大家声明属性时都使用缺省就可以了。局部变量不可以使用权限修饰符。2.3 默认初始化值的情况属性类的属性根据其类型都有默认初始化值。整型byte、short、int、long0浮点型float、double0.0字符型char0 或\u0000布尔型booleanfalse引用数据类型类、数组、接口null局部变量没有默认初始化值。意味着我们在调用局部变量之前一定要显式赋值。特别地形参在调用时我们赋值即可。2.4 在内存中加载的位置属性加载到堆空间中 非static局部变量加载到栈空间类中的方法
方法的使用中可以调用当前类的属性或方法 特殊的方法A中又调用了方法A:递归方法。方法中不可以定义方法。方法的调用
public class Exer3Test {public static void main(String[] args) {Exer3Test test new Exer3Test();//3.1测试
// test.method();//3.2测试//方式一
// int area test.method();
// System.out.println(面积为 area);//方式二
// System.out.println(test.method());//3.3测试int area test.method(12, 10);System.out.println(面积为 area);}//3.1
// public void method(){
// for(int i 0;i 10;i){
// for(int j 0;j 8;j){
// System.out.print(* );
// }
// System.out.println();
// }
// }//3.2
// public int method(){
// for(int i 0;i 10;i){
// for(int j 0;j 8;j){
// System.out.print(* );
// }
// System.out.println();
// }
//
// return 10 * 8;
// }//3.3public int method(int m,int n){for(int i 0;i m;i){for(int j 0;j n;j){System.out.print(* );}System.out.println();}return m * n;}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eHxmTl3Y-1631633254279)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210810171412771.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p9aBEHVk-1631633254280)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210810171356591.png)]
交换两个对象 //问题二使用冒泡排序按学生成绩排序并遍历所有学生信息for(int i 0;i stus.length - 1;i){for(int j 0;j stus.length - 1 - i;j){if(stus[j].score stus[j 1].score){//如果需要换序交换的是数组的元素Student对象Student temp stus[j];stus[j] stus[j 1];stus[j 1] temp;}}}面向对象VS面向过程
1.面向过程强调的是功能行为以函数为最小单位考虑怎样做。
2.面向对象强调具备了功能的对象以类/对象为最小单位考虑谁来做。
变量的分类(按照在类中声明的位置)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BhKTKXVA-1631633254281)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210811150505941.png)]
理解“万物皆对象” 一、理解“万事万物皆对象”1.在Java语言范畴中我们都将功能、结构等封装到类中通过类的实例化来调用具体的功能结构Scanner,String等文件File网络资源URL2.涉及到Java语言与前端Html、后端的数据库交互时前后端的结构在Java层面交互时都体现为类、对象。匿名对象
匿名对象的使用
1.理解我们创建的对象没有显式的赋给一个变量名。即为匿名对象2.特征匿名对象只能调用一次。3.使用如下
package com.wdl.day09;/** 匿名对象的使用* 1.理解我们创建的对象没有显式的赋给一个变量名。即为匿名对象* 2.特征匿名对象只能调用一次。* 3.使用如下**/
public class InstanceTest {public static void main(String[] args) {Phone p new Phone();
// p null;System.out.println(p);p.sendEmail();p.playGame();//匿名对象
// new Phone().sendEmail();
// new Phone().playGame();new Phone().price 1999;new Phone().showPrice();//0.0//**********************************PhoneMall mall new PhoneMall();
// mall.show(p);//匿名对象的使用mall.show(new Phone());}
}class PhoneMall{public void show(Phone phone){phone.sendEmail();phone.playGame();}}class Phone{double price;//价格public void sendEmail(){System.out.println(发送邮件);}public void playGame(){System.out.println(玩游戏);}public void showPrice(){System.out.println(手机价格为 price);}}方法的重载
package com.wdl.day09;/** 方法的重载overload loading...** 1.定义在同一个类中允许存在一个以上的同名方法只要它们的参数个数或者参数类型不同即可。** 两同一不同:同一个类、相同方法名* 参数列表不同参数个数不同参数类型不同** 2. 举例* Arrays类中重载的sort() / binarySearch()** 3.判断是否是重载* 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系** 4. 在通过对象调用方法时如何确定某一个指定的方法* 方法名 --- 参数列表*/
public class OverLoadTest {public static void main(String[] args) {OverLoadTest test new OverLoadTest();test.getSum(1,2);}//如下的4个方法构成了重载public void getSum(int i,int j){System.out.println(1);}public void getSum(double d1,double d2){System.out.println(2);}public void getSum(String s ,int i){System.out.println(3);}public void getSum(int i,String s){System.out.println(4);}//如下的3个方法不能与上述4个方法构成重载
// public int getSum(int i,int j){
// return 0;
// }// public void getSum(int m,int n){
//
// }// private void getSum(int i,int j){
//
// }}
可变个数的形参
package com.wdl.day09;/** 可变个数形参的方法** 1.jdk 5.0新增的内容* 2.具体使用* 2.1 可变个数形参的格式数据类型 ... 变量名* 2.2 当调用可变个数形参的方法时传入的参数个数可以是0个1个,2个。。。* 2.3 可变个数形参的方法与本类中方法名相同形参不同的方法之间构成重载* 2.4 可变个数形参的方法与本类中方法名相同形参类型也相同的数组之间不构成重载。换句话说二者不能共存。* 2.5 可变个数形参在方法的形参中必须声明在末尾* 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。**/
public class MethodArgsTest {public static void main(String[] args) {MethodArgsTest test new MethodArgsTest();test.show(12);
// test.show(hello);
// test.show(hello,world);
// test.show();test.show(new String[]{AA,BB,CC});}public void show(int i){}public void show(String s){System.out.println(show(String));}public void show(String ... strs){System.out.println(show(String ... strs));for(int i 0;i strs.length;i){System.out.println(strs[i]);}}
// //不能与上一个方法同时存在
// public void show(String[] strs){
//
// }//The variable argument type String of the method//show must be the last parameter
// public void show(String ...strs,int i){
//
// }}方法参数的值传递机制
形参是基本数据类型将实参基本数据类型变量的**“数据值”**传递给形参
形参是引用数据类型将实参引用数据类型变量的**“地址值”**传递给形参
基本数据类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-COn673p1-1631633254282)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210811221501431.png)]
引用数据类型(对象中)
public static void main(String[] args) {Person obj new Person();obj.age 5;System.out.println(修改之前age obj.age);// 5
// x是实参change(obj);System.out.println(修改之后age obj.age);// 5}public static void change(Person obj) {obj new Person();System.out.println(change:修改之前age obj.age);obj.age 3;System.out.println(change:修改之后age obj.age);}其中Person类定义为class Person {int age;
}错误交换
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ks3yDG8O-1631633254283)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210811223841293.png)]
正确的交换
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pxpleaSQ-1631633254285)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210811225434360.png)]
探索几道网红题
题目一
package com.wdl.day09;public class Method {public static void main(String args[]) {Method test new Method();test.first();}public void first() {int i 5;Value v new Value();v.i 25;second(v, i);System.out.println(firstv.i);}public void second(Value v, int i) {i 0;v.i 20;Value val new Value();v val;System.out.println(secondv.i i);}
}class Value {int i 15;
}[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dXwidwW6-1631633254286)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812102918990.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VlGA2U7x-1631633254287)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812102855149.png)]
题目二
package com.wdl.day09;/*** 创建人 wdl* 创建时间 2021/8/12* 描述*/
public class ArrayPrintTest {public static void main(String[] args) {int[] arr new int[]{1, 2, 3};System.out.println(arr);//地址值char[] arr1 {a, b,c};System.out.println(arr1);//abc}
}[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7FVSUPe4-1631633254288)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812104158193.png)]
原因
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IryXFg7O-1631633254289)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812103922123.png)]
题目三
相当于又new了一个对象
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xfuVZWzH-1631633254290)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812163448096.png)]
递归
题目一
递归总要不断的向终止条件靠近
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iDPfUPsK-1631633254292)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812111257922.png)]
题目二
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VzWeT8wI-1631633254293)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812163935523.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FG6ot1Hv-1631633254294)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812163919321.png)]
封装性
体现一
Java中通过将属性声明为私有的(private)再提供公共的public方法:getXxx()和setXxx()实现对该属性的操作以实现下述目的
隐藏一个类中不需要对外提供的实现细节
使用者只能通过事先定制好的方法来访问数据可以方便地加入控制逻辑限制对属性的不合理操作
便于修改增强代码的可维护性
体现二
不对外暴露的私有方法
体现三
单例模式(将构造器私有化)
体现四
如果不希望类在包外被调用可以将类设置为缺省的。
权限修饰符
封装性的体现需要权限修饰符来配合。 1.Java规定的4种权限从小到大排列private、缺省、protected 、public 2. 4种权限可以用来修饰类及类的内部结构属性、方法、构造器、内部类 3.具体的4种权限都可以用来修饰类的内部结构属性、方法、构造器、内部类 修饰类的话只能使用缺省、public 总结封装性Java提供了4种权限修饰符来修饰类及类的内部结构体现类及类的内部结构在被调用时的可见性的大小。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fhKIVU31-1631633254295)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812165925156.png)]
构造器
一、构造器的作用 1.创建对象 2.初始化对象的信息
二、说明 1.如果没有显式的定义类的构造器的话则系统默认提供一个空参的构造器 2.定义构造器的格式权限修饰符 类名(形参列表){} 3.一个类中定义的多个构造器彼此构成重载 4.一旦我们显式的定义了类的构造器之后系统就不再提供默认的空参构造器 5.一个类中至少会有一个构造器。
JavaBean
JavaBean是一种Java语言写成的可重用组件。
所谓javaBean是指符合如下标准的Java类
类是公共的
有一个无参的公共的构造器
有属性且有对应的get、set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以
用Java代码创造的对象进行打包并且其他的开发者可以通过内部的JSP
页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用
户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能而不用关
心任何改变
2wh
what why how
this关键字
this关键字的使用
1.this可以用来修饰、调用属性、方法、构造器
2.this修饰属性和方法this理解为当前对象 或 当前正在创建的对象2.1 在类的方法中我们可以使用this.属性或this.方法的方式调用当前对通常情况下我们都选择省略this.。特殊情况下如果方法的形参和类的属性同名时我们的使用this.变量的方式表明此变量是属性而非形参。2.2 在类的构造器中我们可以使用this.属性或this.方法的方式调用当前正但是通常情况下我们都选择省略this.。特殊情况下如果构造器的形参和类的属性同名时的使用this.变量的方式表明此变量是属性而非形参。
3. this调用构造器① 我们在类的构造器中可以显式的使用this(形参列表)方式调用本类中指定的其他② 构造器中不能通过this(形参列表)方式调用自己③ 如果一个类中有n个构造器则最多有 n - 1构造器中使用了this(形参列表)④ 规定this(形参列表)必须声明在当前构造器的首行⑤ 构造器内部最多只能声明一个this(形参列表)用来调用其他的构造器public class PersonTest {public static void main(String[] args) {Person p1 new Person();p1.setAge(1);System.out.println(p1.getAge());p1.eat();System.out.println();Person p2 new Person(Jerry,20);System.out.println(p2.getAge());}
}class Person{private String name;private int age;public Person(){// this.eat();String info Person初始化时需要考虑如下的1,2,3,4...(共40行代码);System.out.println(info);}public Person(String name){this();this.name name;}public Person(int age){this();this.age age;}public Person(String name,int age){this(age);this.name name;//this.age age;//Person初始化时需要考虑如下的1,2,3,4...(共40行代码)}public void setName(String name){this.name name;}public String getName(){return this.name;}public void setAge(int age){this.age age;}public int getAge(){return this.age;}public void eat(){System.out.println(人吃饭);this.study();}public void study(){System.out.println(人学习);}}对象数组
错误一(没有初始化)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uhczG5ft-1631633254296)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812224132218.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WWCEEHUy-1631633254297)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812224148673.png)]
正确写法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qbJ6O5TQ-1631633254298)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210812224317925.png)]
import关键字 在源文件中显式的使用import结构导入指定包下的类、接口 声明在包的声明和类的声明之间 如果需要导入多个结构则并列写出即可 可以使用xxx.*的方式表示可以导入xxx包下的所有结构 如果使用的类或接口是java.lang包下定义的则可以省略import结构 如果使用的类或接口是本包下定义的则可以省略import结构 如果在源文件中使用了不同包下的同名的类则必须至少有一个类需要以全类名的方式显示。 使用xxx.*方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构则仍需要显式导入 import static:导入指定类或接口中的静态结构:属性或方法。
package com.atguigu.java2;import java.lang.reflect.Field;
import java.util.*;import com.atguigu.exer4.Account;
import com.atguigu.exer4.Bank;
import com.atguigu.java2.java3.Dog;import static java.lang.System.*;
import static java.lang.Math.*;public class PackageImportTest {public static void main(String[] args) {String info Arrays.toString(new int[]{1,2,3});Bank bank new Bank();ArrayList list new ArrayList();HashMap map new HashMap();Scanner s null;System.out.println(hello!);Person p new Person();Account acct new Account(1000);//全类名的方式显示com.atguigu.exer3.Account acct1 new com.atguigu.exer3.Account(1000,2000,0.0123);Date date new Date();java.sql.Date date1 new java.sql.Date(5243523532535L);Dog dog new Dog();Field field null;out.println(hello);long num round(123.434);}
}
项目二内存分析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HQHML5rm-1631633254299)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210813162354263.png)]
继承性
一、继承性的好处 ① 减少了代码的冗余提高了代码的复用性 ② 便于功能的扩展 ③ 为之后多态性的使用提供了前提
二、继承性的格式 class A extends B{} A:子类、派生类、subclass B:父类、超类、基类、superclass
2.1体现一旦子类A继承父类B以后子类A中就获取了父类B中声明的所有的属性和方法。 特别的父类中声明为private的属性或方法子类继承父类以后仍然认为获取了父类中私有的结构。 只有因为封装性的影响使得子类不能直接调用父类的结构而已。 2.2 子类继承父类以后还可以声明自己特有的属性或方法实现功能的拓展。 子类和父类的关系不同于子集和集合的关系。 extends延展、扩展
三、Java中关于继承性的规定 1.一个类可以被多个子类继承。 2.Java中类的单继承性一个类只能有一个父类 3.子父类是相对的概念。 4.子类直接继承的父类称为直接父类。间接继承的父类称为间接父类 5.子类继承父类以后就获取了直接父类以及所有间接父类中声明的属性和方法
四、 1. 如果我们没有显式的声明一个类的父类的话则此类继承于java.lang.Object类 2. 所有的java类除java.lang.Object类之外都直接或间接的继承于java.lang.Object类 3. 意味着所有的java类具有java.lang.Object类声明的功能。
重写
方法的重写(override / overwrite)
1.重写子类继承父类以后可以对父类中同名同参数的方法进行覆盖操作
2.应用重写以后当创建子类对象以后通过子类对象调用子父类中的同名同参数的方法时实际执行的是子类重写父类的方法。
3. 重写的规定方法的声明 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{//方法体}约定俗称子类中的叫重写的方法父类中的叫被重写的方法① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符特殊情况子类不能重写父类中声明为private权限的方法③ 返回值类型父类被重写的方法的返回值类型是void则子类重写的方法的返回值类型只能是void父类被重写的方法的返回值类型是A类型则子类重写的方法的返回值类型可以是A类或A类的子类父类被重写的方法的返回值类型是基本数据类型(比如double)则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型具体放到异常处理时候讲**********************************************************************子类和父类中的同名同参数的方法要么都声明为非static的考虑重写要么都声明为static的不是重写。形参列表必须一致
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rx59EyZr-1631633254300)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814003720986.png)]
题目一
编译看左边运行看右边
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x9o8jhLJ-1631633254301)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814180553979.png)]
有可变的参数列表和不可变的参数列表优先调用不可变的参数列表
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0XB2zPWa-1631633254302)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814180653041.png)]
super关键字
super关键字的使用 1.super理解为父类的 2.super可以用来调用属性、方法、构造器
3.super的使用调用属性和方法
3.1 我们可以在子类的方法或构造器中。通过使用super.属性或super.方法的方式显式的调用 父类中声明的属性或方法。但是通常情况下我们习惯省略super. 3.2 特殊情况当子类和父类中定义了同名的属性时我们要想在子类中调用父类中声明的属性则必须显式的 使用super.属性的方式表明调用的是父类中声明的属性。 3.3 特殊情况当子类重写了父类中的方法以后我们想在子类的方法中调用父类中被重写的方法时则必须显式的 使用super.方法的方式表明调用的是父类中被重写的方法。
4.super调用构造器 4.1 我们可以在子类的构造器中显式的使用super(形参列表)的方式调用父类中声明的指定的构造器 4.2 super(形参列表)的使用必须声明在子类构造器的首行 4.3 我们在类的构造器中针对于this(形参列表)或super(形参列表)“只能二选一不能同时出现 4.4 在构造器的首行没有显式的声明this(形参列表)“或super(形参列表)”则默认调用的是父类中空参的构造器super() 4.5 在类的多个构造器中至少有一个类的构造器中使用了super(形参列表)”调用父类中的构造器
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XHm57SpN-1631633254303)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814132845483.png)]
子类对象实例化的全过程
1. 从结果上来看继承性子类继承父类以后就获取了父类中声明的属性或方法。创建子类的对象在堆空间中就会加载所有父类中声明的属性。2. 从过程上来看当我们通过子类的构造器创建子类对象时我们一定会直接或间接的调用其父类的构造器进而调用父类的父类的构造器...直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构所以才可以看到内存中有父类中的结构子类对象才可以考虑进行调用。明确虽然创建子类对象时调用了父类的构造器但是自始至终就创建过一个对象即为new的子类对象。
多态性
多态性只适用于方法不适用于属性
1.若子类重写了父类方法就意味着子类里定义的方法彻底覆盖了父类里的同名方法系统将不可能把父类里的方法转移到子类中编译看左边运行看右边2.对于实例变量则不存在这样的现象即使子类里定义了与父类完全相同的实例变量这个实例变量依然不可能覆盖父类中定义的实例变量编译运行都看左边[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vVPhZwX5-1631633254304)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814171459958.png)]
1.理解多态性可以理解为一个事物的多种形态。 2.何为多态性 对象的多态性父类的引用指向子类的对象或子类的对象赋给父类的引用
3.多态的使用虚拟方法调用 有了对象的多态性以后我们在编译期只能调用父类中声明的方法但在运行期我们实际执行的是子类重写父类的方法。 总结编译看左边运行看右边。
4.多态性的使用前提 ① 类的继承关系 ② 方法的重写
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lONAgHxX-1631633254305)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814150424371.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kM13r653-1631633254306)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814165711245.png)]
调用子类特有的属性和方法(强制类型转换)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rqnfR59B-1631633254307)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814165829408.png)]
注意事项
先判断对象a是否是类A的实例
题目一
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-De4vbAUB-1631633254308)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815141043218.png)]
题目二
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sKB19FGl-1631633254309)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210901145353698.png)]
instanceof关键字
instanceof关键字的使用
a instanceof A:判断对象a是否是类A的实例。如果是返回true如果不是返回false。
使用情境为了避免在向下转型时出现ClassCastException的异常我们在向下转型之前先 进行instanceof的判断一旦返回true就进行向下转型。如果返回false不进行向下转型。
如果 a instanceof A返回true,则 a instanceof B也返回true. 其中类B是类A的父类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8hetTZ5y-1631633254309)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210814170058517.png)]
举例 //练习//问题一编译时通过运行时不通过//举例一
// Person p3 new Woman();
// Man m3 (Man)p3;//举例二
// Person p4 new Person();
// Man m4 (Man)p4;//问题二编译通过运行时也通过
// Object obj new Woman();
// Person p (Person)obj;//问题三编译不通过
// Man m5 new Woman();// String str new Date();// Object o new Date();
// String str1 (String)o;Object类
java.lang.Object类 1.Object类是所有Java类的根父类 2.如果在类的声明中未使用extends关键字指明其父类则默认父类为java.lang.Object类 3.Object类中的功能(属性、方法)就具有通用性。 属性无 方法equals() / toString() / getClass() /hashCode() / clone() / finalize() wait() 、 notify()、notifyAll()
Object类只声明了一个空参的构造器
面试题 final、finally、finalize的区别 和 equals() 区别
一、回顾 的使用运算符
1. 可以使用在基本数据类型变量和引用数据类型变量中
2. 如果比较的是基本数据类型变量比较两个变量保存的数据是否相等。不一定类型要相同如果比较的是引用数据类型变量比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
补充 ** 符号使用时必须保证符号左右两边的变量类型一致。**
二、equals()方法的使用
1. 是一个方法而非运算符
2. 只能适用于引用数据类型
3. Object类中equals()的定义public boolean equals(Object obj) {return (this obj);}说明Object类中定义的equals()和的作用是相同的比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后比较的不是两个引用的地址是否相同而是比较两个对象的实体内容是否相同。
5. 通常情况下我们自定义的类如果使用equals()的话也通常是比较两个对象的实体内容是否相同。那么我们就需要对Object类中的equals()进行重写.重写的原则比较两个对象的实体内容是否相同.package com.wdl.day13;import java.util.Date;
public class EqualsTest {public static void main(String[] args) {//基本数据类型int i 10;int j 10;double d 10.0;System.out.println(i j);//trueSystem.out.println(i d);//trueboolean b true;
// System.out.println(i b);char c 10;System.out.println(i c);//truechar c1 A;char c2 65;System.out.println(c1 c2);//true//引用类型Customer cust1 new Customer(Tom,21);Customer cust2 new Customer(Tom,21);System.out.println(cust1 cust2);//falseString str1 new String(atguigu);String str2 new String(atguigu);System.out.println(str1 str2);//falseSystem.out.println(****************************);System.out.println(cust1.equals(cust2));//false---trueSystem.out.println(str1.equals(str2));//trueDate date1 new Date(32432525324L);Date date2 new Date(32432525324L);System.out.println(date1.equals(date2));//true}
}注意事项
空指针
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aNlQCZgJ-1631633254310)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815110445691.png)]
题目一
String存放在常量池中
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YRvearG7-1631633254312)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815111759486.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oHUgzgVD-1631633254313)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815111249169.png)]
toString()
Object类中toString()的使用
1. **当我们输出一个对象的引用时实际上就是调用当前对象的toString()**
2. Object类中toString()的定义public String toString() {return getClass().getName() Integer.toHexString(hashCode());}
3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时返回实体内容信息
4. 自定义类也可以重写toString()方法当调用此方法时返回对象的实体内容package com.wdl.day13;import java.util.Date;
public class ToStringTest {public static void main(String[] args) {Customer cust1 new Customer(Tom,21);System.out.println(cust1.toString());//com.atguigu.java1.Customer15db9742--Customer[name Tom,age 21]System.out.println(cust1);//com.atguigu.java1.Customer15db9742--Customer[name Tom,age 21]String str new String(MM);System.out.println(str);//MMDate date new Date(4534534534543L);System.out.println(date.toString());//Mon Sep 11 08:55:34 GMT08:00 2113}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-raEMolOT-1631633254314)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815112625000.png)]
题目一
当我们输出一个对象的引用时实际上就是调用当前对象的toString()
但是底层有保护机制当此参数为null时直接进行输出
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DP77moYn-1631633254315)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815152028279.png)]
JUnit单元测试
1.选中当前工程 - 右键选择build path - add libraries - JUnit 4 - 下一步 2.创建Java类进行单元测试。 此时的Java类要求① 此类是public的 ②此类提供公共的无参的构造器 3.此类中声明单元测试方法。 此时的单元测试方法方法的权限是public,没有返回值没有形参 4.此单元测试方法上需要声明注解Test,并在单元测试类中导入import org.junit.Test; 5.声明好单元测试方法以后就可以在方法体内测试相关的代码。 6.写完代码以后左键双击单元测试方法名右键run as - JUnit Test 说明 1.如果执行结果没有任何异常绿条 2.如果执行结果出现异常红条
package com.wdl.day13;import java.util.Date;import org.junit.Test;public class JUnitTest {int num 10;Testpublic void testEquals(){String s1 MM;String s2 MM;System.out.println(s1.equals(s2));//ClassCastException的异常
// Object obj new String(GG);
// Date date (Date)obj;System.out.println(num);show();}public void show(){num 20;System.out.println(show()....);}Testpublic void testToString(){String s2 MM;System.out.println(s2.toString());}
}包装类(Wrapper)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dCdI1SWw-1631633254316)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815114441101.png)]
基本数据类型、包装类、String三者之间的相互转换
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WR02rmtq-1631633254317)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815124847192.png)]
package com.wdl.day13;import org.junit.Test;/** 包装类的使用:* 1.java提供了8种基本数据类型对应的包装类使得基本数据类型的变量具有类的特征** 2.掌握的基本数据类型、包装类、String三者之间的相互转换****/
public class WrapperTest {//String类型 ---基本数据类型、包装类调用包装类的parseXxx(String s)Testpublic void test5(){String str1 123;//错误的情况
// int num1 (int)str1;
// Integer in1 (Integer)str1;//可能会报NumberFormatExceptionint num2 Integer.parseInt(str1);System.out.println(num2 1);String str2 true1;boolean b1 Boolean.parseBoolean(str2);System.out.println(b1);}//基本数据类型、包装类---String类型调用String重载的valueOf(Xxx xxx)Testpublic void test4(){int num1 10;//方式1连接运算String str1 num1 ;//方式2调用String的valueOf(Xxx xxx)float f1 12.3f;String str2 String.valueOf(f1);//12.3Double d1 new Double(12.4);String str3 String.valueOf(d1);System.out.println(str2);System.out.println(str3);//12.4}/** JDK 5.0 新特性自动装箱 与自动拆箱*/Testpublic void test3(){
// int num1 10;
// //基本数据类型--包装类的对象
// method(num1);//自动装箱基本数据类型 ---包装类int num2 10;Integer in1 num2;//自动装箱boolean b1 true;Boolean b2 b1;//自动装箱//自动拆箱包装类---基本数据类型System.out.println(in1.toString());int num3 in1;//自动拆箱}public void method(Object obj){System.out.println(obj);}//包装类---基本数据类型:调用包装类Xxx的xxxValue()Testpublic void test2(){Integer in1 new Integer(12);int i1 in1.intValue();System.out.println(i1 1);Float f1 new Float(12.3);float f2 f1.floatValue();System.out.println(f2 1);}//基本数据类型 ---包装类调用包装类的构造器Testpublic void test1(){int num1 10;
// System.out.println(num1.toString());Integer in1 new Integer(num1);System.out.println(in1.toString());Integer in2 new Integer(123);System.out.println(in2.toString());//报异常
// Integer in3 new Integer(123abc);
// System.out.println(in3.toString());Float f1 new Float(12.3f);Float f2 new Float(12.3);System.out.println(f1);System.out.println(f2);Boolean b1 new Boolean(true);Boolean b2 new Boolean(TrUe);System.out.println(b2);Boolean b3 new Boolean(true123);System.out.println(b3);//falseOrder order new Order();System.out.println(order.isMale);//falseSystem.out.println(order.isFemale);//null}}class Order{boolean isMale;Boolean isFemale;
}题目一
类型提升(三元运算符:两边的类型一致)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FIcs7nn6-1631633254319)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815132657172.png)]
题目二
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DrvSHvnH-1631633254320)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815133259897.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uWCtkLQb-1631633254321)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815133058874.png)]
Vector类
数组一旦创建长度就固定不变所以在创建数组前就需要知道它的长度。而向量类java.util.Vector可以根据需要动态伸缩。
创建Vector对象Vector vnew Vector(); 给向量添加元素v.addElement(Object obj); //obj必须是对象 取出向量中的元素Object objv.elementAt(0); 注意第一个元素的下标是0返回值是Object类型的。 计算向量的长度v.size();
package com.atguigu.exer4;import java.util.Scanner;
import java.util.Vector;/** 利用Vector代替数组处理从键盘读入学生成绩以负数代表输入结束找出最高分并输出学生成绩等级。若与最高分相差10分内A等20分内B等30分内C等其它D等* * * * */
public class ScoreTest {public static void main(String[] args) {//1.实例化Scanner用于从键盘获取学生成绩Scanner scan new Scanner(System.in);//2.创建Vector对象Vector vnew Vector();相当于原来的数组Vector v new Vector();//3.通过for(;;)或while(true)方式给Vector中添加数组int maxScore 0;for(;;){System.out.println(请输入学生成绩以负数代表输入结束);int score scan.nextInt();//3.2 当输入是负数时跳出循环if(score 0){break;}if(score 100){System.out.println(输入的数据非法请重新输入);continue;}//3.1 添加操作v.addElement(Object obj)//jdk5.0之前
// Integer inScore new Integer(score);
// v.addElement(inScore);//多态//jdk5.0之后v.addElement(score);//自动装箱//4.获取学生成绩的最大值if(maxScore score){maxScore score;}}//5.遍历Vector得到每个学生的成绩并与最大成绩比较得到每个学生的等级。char level;for(int i 0;i v.size();i){Object obj v.elementAt(i);//jdk 5.0之前
// Integer inScore (Integer)obj;
// int score inScore.intValue();//jdk 5.0之后int score (int)obj;if(maxScore - score 10){level A;}else if(maxScore - score 20){level B;}else if(maxScore - score 30){level C;}else{level D;}System.out.println(student- i score is score ,level is level);}}
}
static关键字
1.static:静态的
2.static可以用来修饰属性、方法、代码块、内部类
3.使用static修饰属性静态变量或类变量3.1 属性按是否使用static修饰又分为静态属性 vs 非静态属性(实例变量)实例变量我们创建了类的多个对象每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时不会导致其他对象中同样的属性值的修改。静态变量我们创建了类的多个对象多个对象共享同一个静态变量。当通过某一个对象修改静态变量时会导致其他对象调用此静态变量时是修改过了的。3.2 static修饰属性的其他说明① 静态变量随着类的加载而加载。可以通过类.静态变量的方式进行调用② 静态变量的加载要早于对象的创建。③ 由于类只会加载一次则静态变量在内存中也只会存在一份存在方法区的静态域中。④ 类变量 实例变量类 yes no对象 yes yes3.3 静态属性举例System.out; Math.PI;
4.使用static修饰方法静态方法① 随着类的加载而加载可以通过类.静态方法的方式进行调用② 静态方法 非静态方法类 yes no对象 yes yes③ 静态方法中只能调用静态的方法或属性非静态方法中既可以调用非静态的方法或属性也可以调用静态的方法或属性
5. static注意点5.1 在静态的方法内不能使用this关键字、super关键字5.2 关于静态属性和静态方法的使用大家都从生命周期的角度去理解。
6. 开发中如何确定一个属性是否要声明为static的 属性是可以被多个对象所共享的不会随着对象的不同而不同的。 类中的常量也常常声明为static开发中如何确定一个方法是否要声明为static的 操作静态属性的方法通常设置为static的 工具类中的方法习惯上声明为static的。 比如Math、Arrays、Collectionspackage com.wdl.day14;
public class StaticTest {public static void main(String[] args) {Chinese.nation 中国;Chinese c1 new Chinese();c1.name 姚明;c1.age 40;c1.nation CHN;Chinese c2 new Chinese();c2.name 马龙;c2.age 30;c2.nation CHINA;System.out.println(c1.nation);//编译不通过
// Chinese.name 张继科;c1.eat();Chinese.show();//编译不通过
// Chinese.eat();
// Chinese.info();}
}
//中国人
class Chinese{String name;int age;static String nation;public void eat(){System.out.println(中国人吃中餐);//调用非静态结构this.info();System.out.println(name : name);//调用静态结构walk();System.out.println(nation : nation);}public static void show(){System.out.println(我是一个中国人);//不能调用非静态的结构
// eat();
// name Tom;//可以调用静态的结构System.out.println(Chinese.nation);walk();}public void info(){System.out.println(name : name ,age : age);}public static void walk(){}
}
类变量VS实例变量内存解析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1QfCMi6f-1631633254322)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815181710632.png)]
单例 (Singleton)设计模式
所谓类的单例设计模式就是采取一定的方法保证在整个的软件系统中对某个类只能存在一个对象实例并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象我们首先必须将类的构造器的访问权限设置为private这样就不能用new操作符在类的外部产生类的对象了但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象只能调用该类的某个静态方法以返回类内部创建的对象静态方法只能访问类中的静态成员变量所以指向类内部产生的该类对象的变量也必须定义成静态的。
1. 所谓类的单例设计模式就是采取一定的方法保证在整个的软件系统中对某个类只能存在一个对象实例。
2. 如何实现饿汉式 vs 懒汉式
3. 区分饿汉式 和 懒汉式饿汉式坏处对象加载时间过长。好处饿汉式是线程安全的懒汉式好处延迟对象的创建。目前的写法坏处线程不安全。---到多线程内容时再修改饿汉式
package com.wdl.day14;
public class SingletonTest1 {public static void main(String[] args) {
// Bank bank1 new Bank();
// Bank bank2 new Bank();Bank bank1 Bank.getInstance();Bank bank2 Bank.getInstance();System.out.println(bank1 bank2);}
}//饿汉式
class Bank{//1.私有化类的构造器private Bank(){}//2.内部创建类的对象//4.要求此对象也必须声明为静态的private static Bank instance new Bank();//3.提供公共的静态的方法返回类的对象public static Bank getInstance(){return instance;}
}package com.wdl.day15;public class SingletonTest {public static void main(String[] args) {Bank bank1 Bank.instance;// Bank.instance null;Bank bank2 Bank.instance;System.out.println(bank1 bank2);}
}class Bank{private Bank(){}public static final Bank instance new Bank();}懒汉式
package com.wdl.day14;
/** 单例模式的懒汉式实现**/
public class SingletonTest2 {public static void main(String[] args) {Order order1 Order.getInstance();Order order2 Order.getInstance();System.out.println(order1 order2);}
}class Order{//1.私有化类的构造器private Order(){}//2.声明当前类对象没有初始化//4.此对象也必须声明为static的private static Order instance null;//3.声明public、static的返回当前类对象的方法public static Order getInstance(){if(instance null){instance new Order();}return instance;}}解决线程不安全问题
package com.atguigu.java1;/*** 使用同步机制将单例模式中的懒汉式改写为线程安全的** author shkstart* create 2019-02-15 下午 2:50*/
public class BankTest {}class Bank{private Bank(){}private static Bank instance null;public static Bank getInstance(){//方式一效率稍差
// synchronized (Bank.class) {
// if(instance null){
//
// instance new Bank();
// }
// return instance;
// }//方式二效率更高if(instance null){synchronized (Bank.class) {if(instance null){instance new Bank();}}}return instance;}}
应用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-czbCg4m3-1631633254324)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815194141846.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cZVK1wYA-1631633254325)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815195114809.png)]
main()方法
main()方法的使用说明
main()方法作为程序的入口main()方法也是一个普通的静态方法main()方法可以作为我们与控制台交互的方式。之前使用Scanner
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sFtl1AyR-1631633254326)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815195907304.png)]
代码块
1. 代码块的作用用来初始化类、对象
2. 代码块如果有修饰的话只能使用static.
3. 分类静态代码块 vs 非静态代码块
4. 静态代码块内部可以有输出语句随着类的加载而执行,而且只执行一次作用初始化类的信息如果一个类中定义了多个静态代码块则按照声明的先后顺序执行静态代码块的执行要优先于非静态代码块的执行静态代码块内只能调用静态的属性、静态的方法不能调用非静态的结构
5. 非静态代码块内部可以有输出语句随着对象的创建而执行每创建一个对象就执行一次非静态代码块作用可以在创建对象时对对象的属性等进行初始化如果一个类中定义了多个非静态代码块则按照声明的先后顺序执行非静态代码块内可以调用静态的属性、静态的方法或非静态的属性、非静态的方法package com.wdl.day14;
public class BlockTest {public static void main(String[] args) {String desc Person.desc;System.out.println(desc);Person p1 new Person();Person p2 new Person();System.out.println(p1.age);Person.info();}
}class Person{//属性String name;int age;static String desc 我是一个人;//构造器public Person(){}public Person(String name,int age){this.name name;this.age age;}//非static的代码块{System.out.println(hello, block - 2);}{System.out.println(hello, block - 1);//调用非静态结构age 1;eat();//调用静态结构desc 我是一个爱学习的人1;info();}//static的代码块static{System.out.println(hello,static block-2);}static{System.out.println(hello,static block-1);//调用静态结构desc 我是一个爱学习的人;info();//不可以调用非静态结构
// eat();
// name Tom;}//方法public void eat(){System.out.println(吃饭);}Overridepublic String toString() {return Person [name name , age age ];}public static void info(){System.out.println(我是一个快乐的人);}}题目一
总结由父及子静态先行
package com.atguigu.java3;
//总结由父及子静态先行
class Root{static{System.out.println(Root的静态初始化块);}{System.out.println(Root的普通初始化块);}public Root(){super();System.out.println(Root的无参数的构造器);}
}
class Mid extends Root{static{System.out.println(Mid的静态初始化块);}{System.out.println(Mid的普通初始化块);}public Mid(){super();System.out.println(Mid的无参数的构造器);}public Mid(String msg){//通过this调用同一类中重载的构造器this();System.out.println(Mid的带参数构造器其参数值 msg);}
}
class Leaf extends Mid{static{System.out.println(Leaf的静态初始化块);}{System.out.println(Leaf的普通初始化块);} public Leaf(){//通过super调用父类中有一个字符串参数的构造器super(尚硅谷);System.out.println(Leaf的构造器);}
}
public class LeafTest{public static void main(String[] args){new Leaf(); System.out.println();new Leaf();}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yz9UneM7-1631633254328)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210815202131049.png)]
对属性可以赋值的位置
对属性可以赋值的位置 ①默认初始化 ②显式初始化/⑤在代码块中赋值 ③构造器中初始化 ④有了对象以后可以通过对象.属性或对象.方法的方式进行赋值 执行的先后顺序① - ② / ⑤ - ③ - ④
package com.atguigu.java3;public class OrderTest {public static void main(String[] args) {Order order new Order();System.out.println(order.orderId);}
}class Order{int orderId 3;{orderId 4;}}
final关键字
final可以用来修饰的结构类、方法、变量final 用来修饰一个类:此类不能被其他类所继承。 比如String类、System类、StringBuffer类final 用来修饰方法表明此方法不可以被重写 比如Object类中getClass();final 用来修饰变量此时的变量就称为是一个常量 4.1 final修饰属性可以考虑赋值的位置有1.显式初始化、2.代码块中初始化、3.构造器中初始化 4.2 final修饰局部变量 尤其是使用final修饰形参时表明此形参是一个常量。当我们调用此方法时给常量形参赋一个实参。一旦赋值以后就只能在方法体内使用此形参但不能进行重新赋值。 static final 用来修饰属性全局常量
package com.wdl.day14;
public class FinalTest {final int WIDTH 0;final int LEFT;final int RIGHT;
// final int DOWN;{LEFT 1;}public FinalTest(){RIGHT 2;}public FinalTest(int n){RIGHT n;}// public void setDown(int down){
// this.DOWN down;
// }public void doWidth(){
// width 20;}public void show(){final int NUM 10;//常量
// NUM 20;}public void show(final int num){
// num 20;//编译不通过System.out.println(num);}public static void main(String[] args) {int num 10;num num 5;FinalTest test new FinalTest();
// test.setDown(3);test.show(10);}
}final class FinalA{}//class B extends FinalA{
//
//}//class C extends String{
//
//}class AA{public final void show(){}
}class BB extends AA{// public void show(){
//
// }
}题目一
正确
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ETqxt3xf-1631633254329)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210816110605097.png)]
abstract关键字
abstract关键字的使用
1.abstract:抽象的
2.abstract可以用来修饰的结构类、方法
3. abstract修饰类抽象类 此类不能实例化 抽象类中一定有构造器便于子类实例化时调用涉及子类对象实例化的全过程 开发中都会提供抽象类的子类让子类对象实例化完成相关的操作
4. abstract修饰方法抽象方法 抽象方法只有方法的声明没有方法体 包含抽象方法的类一定是一个抽象类。反之抽象类中可以没有抽象方法的。 若子类重写了父类中的所有的抽象方法后此子类方可实例化若子类没有重写父类中的所有的抽象方法则此子类也是一个抽象类需要使用abstract修饰abstract使用上的注意点
1.abstract不能用来修饰属性、构造器等结构
2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类package com.wdl.day15;public class AbstractTest {public static void main(String[] args) {//一旦Person类抽象了就不可实例化
// Person p1 new Person();
// p1.eat();}
}abstract class Creature{public abstract void breath();
}abstract class Person extends Creature{String name;int age;public Person(){}public Person(String name,int age){this.name name;this.age age;}//不是抽象方法
// public void eat(){
//
// }//抽象方法public abstract void eat();public void walk(){System.out.println(人走路);}}class Student extends Person{public Student(String name,int age){super(name,age);}public Student(){}public void eat(){System.out.println(学生多吃有营养的食物);}Overridepublic void breath() {System.out.println(学生应该呼吸新鲜的没有雾霾的空气);}
}抽象类的匿名子类
package com.wdl.day15;
/** 抽象类的匿名子类**/
public class PersonTest {public static void main(String[] args) {method(new Student());//匿名对象Worker worker new Worker();method1(worker);//非匿名的类非匿名的对象method1(new Worker());//非匿名的类匿名的对象System.out.println(********************);//创建了一匿名子类的对象pPerson p new Person(){Overridepublic void eat() {System.out.println(吃东西);}Overridepublic void breath() {System.out.println(好好呼吸);}};method1(p);System.out.println(********************);//创建匿名子类的匿名对象method1(new Person(){Overridepublic void eat() {System.out.println(吃好吃东西);}Overridepublic void breath() {System.out.println(好好呼吸新鲜空气);}});}public static void method1(Person p){p.eat();p.breath();}public static void method(Student s){}
}class Worker extends Person{Overridepublic void eat() {}Overridepublic void breath() {}}模板方法设计模式(TemplateMethod)
抽象类体现的就是一种模板模式的设计抽象类作为多个子类的通用模
板子类在抽象类的基础上进行扩展、改造但子类总体上会保留抽象
类的行为方式。
解决的问题
当功能内部一部分实现是确定的一部分实现是不确定的。这时可以把不确定的部分暴露出去让子类去实现。
换句话说在软件开发中实现一个算法时整体步骤很固定、通用这些步骤已经在父类中写好了。但是某些部分易变易变部分可以抽象出来供不同子类实现。这就是一种模板模式。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vBVDXmS2-1631633254330)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210816150210963.png)]
interface关键字
接口的使用
1.接口使用interface来定义
2.Java中接口和类是并列的两个结构
3.如何定义接口定义接口中的成员3.1 JDK7及以前只能定义全局常量和抽象方法全局常量public static final的.但是书写时可以省略不写抽象方法public abstract的3.2 JDK8除了定义全局常量和抽象方法之外还可以定义静态方法、默认方法略
4. 接口中不能定义构造器的意味着接口不可以实例化
5. Java开发中接口通过让类去实现(implements)的方式来使用.如果实现类覆盖了接口中的所有抽象方法则此实现类就可以实例化如果实现类没有覆盖接口中所有的抽象方法则此实现类仍为一个抽象类
6. Java类可以实现多个接口 ---弥补了Java单继承性的局限性格式class AA extends BB implements CC,DD,EE
7. 接口与接口之间可以继承而且可以多继承
*******************************
8. 接口的具体使用体现多态性
9. 接口实际上可以看做是一种规范package com.wdl.day15;public class InterfaceTest {public static void main(String[] args) {System.out.println(Flyable.MAX_SPEED);System.out.println(Flyable.MIN_SPEED);
// Flyable.MIN_SPEED 2;Plane plane new Plane();plane.fly();}
}interface Flyable{//全局常量public static final int MAX_SPEED 7900;//第一宇宙速度int MIN_SPEED 1;//省略了public static final//抽象方法public abstract void fly();//省略了public abstractvoid stop();//Interfaces cannot have constructors
// public Flyable(){
//
// }
}interface Attackable{void attack();}class Plane implements Flyable{Overridepublic void fly() {System.out.println(通过引擎起飞);}Overridepublic void stop() {System.out.println(驾驶员减速停止);}}abstract class Kite implements Flyable{Overridepublic void fly() {}}class Bullet extends Object implements Flyable,Attackable,CC{Overridepublic void attack() {// TODO Auto-generated method stub}Overridepublic void fly() {// TODO Auto-generated method stub}Overridepublic void stop() {// TODO Auto-generated method stub}Overridepublic void method1() {// TODO Auto-generated method stub}Overridepublic void method2() {// TODO Auto-generated method stub}}
//************************************interface AA{void method1();
}
interface BB{void method2();
}interface CC extends AA,BB{}题目一
面试题抽象类与接口有哪些异同
相同点:不能实例化都可以被继承
不同点:抽象类:有构造器。接口:不能声明构造器。
多继承vs单继承
题目二
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j1ECKbay-1631633254332)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210816173040793.png)]
题目三
public static final
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gazuzrdb-1631633254333)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210816173332436.png)]
代理模式(Proxy)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HAaPjTcN-1631633254334)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210816165746590.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3RAKxfyT-1631633254336)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210816170203481.png)]
package com.wdl.day15;
/** 接口的应用代理模式**/
public class NetWorkTest {public static void main(String[] args) {Server server new Server();
// server.browse();ProxyServer proxyServer new ProxyServer(server);proxyServer.browse();}
}interface NetWork{public void browse();}//被代理类
class Server implements NetWork{Overridepublic void browse() {System.out.println(真实的服务器访问网络);}}
//代理类
class ProxyServer implements NetWork{private NetWork work;public ProxyServer(NetWork work){this.work work;}public void check(){System.out.println(联网之前的检查工作);}Overridepublic void browse() {check();work.browse();}}工厂模式
工厂模式实现了创建者与调用者的分离即将创建对象的具体过程屏蔽隔离起来达到提高灵活性的目的。其实设计模式和面向对象设计原则都是为了使得开发项目更加容易扩展和维护解决方式就是一个“分工”。
无工厂模式
package com.atguigu.pattern.factory.nofactory;
interface Car{
void run();
}
class Audi implements Car{
public void run() {
System.out.println(奥迪在跑);
} }
class BYD implements Car{
public void run() {
System.out.println(比亚迪在跑);
} }
public class Client01 {
public static void main(String[] args) {
Car a new Audi();
Car b new BYD();
a.run();
b.run();
} }简单工厂模式
用来生产同一等级结构中的任意产品。对于增加新的产品需要修改已有代码
缺点对于增加新产品不修改代码的话是无法扩展的。违反了开闭原则对扩展开放对修改封闭。
package com.atguigu.pattern.factory.simple;
interface Car {
void run();
}
class Audi implements Car {
public void run() {
System.out.println(奥迪在跑);
} }
class BYD implements Car {
public void run() {
System.out.println(比亚迪在跑);
} }//工厂类
class CarFactory {
//方式一
public static Car getCar(String type) {
if (奥迪.equals(type)) {
return new Audi();
} else if (比亚迪.equals(type)) {
return new BYD();
} else {
return null; } }
//方式二
// public static Car getAudi() {
// return new Audi();
// }
//
// public static Car getByd() {
// return new BYD();
// } }
public class Client02 {
public static void main(String[] args) {
Car a CarFactory.getCar(奥迪);
a.run();
Car b CarFactory.getCar(比亚迪);
b.run();
} }工厂方法模式
用来生产同一等级结构中的固定产品。
package com.atguigu.pattern.factory.method;
interface Car{
void run();
}
//两个实现类
class Audi implements Car{
public void run() {
System.out.println(奥迪在跑);
} }
class BYD implements Car{
public void run() {
System.out.println(比亚迪在跑);
} }
//工厂接口
interface Factory{
Car getCar();
}
//两个工厂类
class AudiFactory implements Factory{
public Audi getCar(){
return new Audi();
} }
class BydFactory implements Factory{
public BYD getCar(){
return new BYD();
} }
public class Client {
public static void main(String[] args) {
Car a new AudiFactory().getCar();
Car b new BydFactory().getCar();
a.run();
b.run();
} }抽象工厂模式
用来生产不同产品族的全部产品。对于增加新的产品无能为力支持增加产品族
比较对象大小
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AAy0onm4-1631633254337)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210816184326113.png)]
Java8中接口的新特性
知识点1
接口中定义的静态方法只能通过接口来调用。 CompareA.method1();
知识点2
通过实现类的对象可以调用接口中的默认方法。如果实现类重写了接口中的默认方法调用时仍然调用的是重写以后的方法 s.method2();
知识点3
如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法那么子类在没有重写此方法的情况下默认调用的是父类中的同名同参数的方法。–类优先原则
知识点4
如果实现类实现了多个接口而这多个接口中定义了同名同参数的默认方法那么在实现类没有重写此方法的情况下报错。–接口冲突。 这就需要我们必须在实现类中重写此方法 s.method3();
知识点5
如何在子类(或实现类)的方法中调用父类、接口中被重写的方法 public void myMethod(){ method3();//调用自己定义的重写的方法 super.method3();//调用 的是父类中声明的 //调用接口中的默认方法 CompareA.super.method3(); CompareB.super.method3(); }
package com.wdl.day15;public class SubClassTest {public static void main(String[] args) {SubClass s new SubClass();// s.method1();
// SubClass.method1();//知识点1接口中定义的静态方法只能通过接口来调用。CompareA.method1();//知识点2通过实现类的对象可以调用接口中的默认方法。//如果实现类重写了接口中的默认方法调用时仍然调用的是重写以后的方法s.method2();//知识点3如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法//那么子类在没有重写此方法的情况下默认调用的是父类中的同名同参数的方法。--类优先原则//知识点4如果实现类实现了多个接口而这多个接口中定义了同名同参数的默认方法//那么在实现类没有重写此方法的情况下报错。--接口冲突。//这就需要我们必须在实现类中重写此方法s.method3();}}class SubClass extends SuperClass implements CompareA,CompareB{public void method2(){System.out.println(SubClass上海);}public void method3(){System.out.println(SubClass深圳);}//知识点5如何在子类(或实现类)的方法中调用父类、接口中被重写的方法public void myMethod(){method3();//调用自己定义的重写的方法super.method3();//调用的是父类中声明的//调用接口中的默认方法CompareA.super.method3();CompareB.super.method3();}
}内部类
类的内部成员之五内部类
1. Java中允许将一个类A声明在另一个类B中则类A就是内部类类B称为外部类
2.内部类的分类成员内部类静态、非静态 vs 局部内部类(方法内、代码块内、构造器内)
3.成员内部类一方面作为外部类的成员调用外部类的结构可以被static修饰可以被4种不同的权限修饰另一方面作为一个类 类内可以定义属性、方法、构造器等 可以被final修饰表示此类不能被继承。言外之意不使用final就可以被继承 可以被abstract修饰
4.关注如下的3个问题4.1 如何实例化成员内部类的对象4.2 如何在成员内部类中区分调用外部类的结构4.3 开发中局部内部类的使用 见《InnerClassTest1.java》package com.wdl.day15;public class InnerClassTest {public static void main(String[] args) {//创建Dog实例(静态的成员内部类):Person.Dog dog new Person.Dog();dog.show();//创建Bird实例(非静态的成员内部类):
// Person.Bird bird new Person.Bird();//错误的Person p new Person();Person.Bird bird p.new Bird();bird.sing();System.out.println();bird.display(黄鹂);}
}class Person{String name 小明;int age;public void eat(){System.out.println(人吃饭);}//静态成员内部类static class Dog{String name;int age;public void show(){System.out.println(卡拉是条狗);
// eat();}}//非静态成员内部类class Bird{String name 杜鹃;public Bird(){}public void sing(){System.out.println(我是一只小小鸟);Person.this.eat();//调用外部类的非静态属性eat();System.out.println(age);}public void display(String name){System.out.println(name);//方法的形参System.out.println(this.name);//内部类的属性System.out.println(Person.this.name);//外部类的属性}}public void method(){//局部内部类class AA{}}{//局部内部类class BB{}}public Person(){//局部内部类class CC{}}}使用
package com.wdl.day15;public class InnerClassTest1 {//开发中很少见public void method(){//局部内部类class AA{}}//返回一个实现了Comparable接口的类的对象public Comparable getComparable(){//创建一个实现了Comparable接口的类:局部内部类//方式一
// class MyComparable implements Comparable{
//
// Override
// public int compareTo(Object o) {
// return 0;
// }
//
// }
//
// return new MyComparable();//方式二return new Comparable(){Overridepublic int compareTo(Object o) {return 0;}};}}注意点
在局部内部类的方法中比如show如果调用局部内部类所声明的方法(比如method)中的局部变量(比如num)的话,要求此局部变量声明为final的。
jdk 7及之前版本要求此局部变量显式的声明为final的 jdk 8及之后的版本可以省略final的声明
package com.atguigu.java;public class InnerClassTest {// public void onCreate(){
//
// int number 10;
//
// View.OnClickListern listener new View.OnClickListener(){
//
// public void onClick(){
// System.out.println(hello!);
// System.out.println(number);
// }
//
// }
//
// button.setOnClickListener(listener);
//
// }public void method(){//局部变量int num 10;class AA{public void show(){
// num 20;System.out.println(num);}}}}
总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MET1wtkn-1631633254338)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210817094307361.png)]
异常
异常分类
Error
Java虚拟机无法解决的严重问题。如JVM系统内部错误、资源耗尽等严重情况。比如StackOverflowError和OOM。一般不编写针对性的代码进行处理。
Exception:
其它因编程错误或偶然的外在因素导致的一般性问题可以使用针对性的代码进行处理。例如
空指针访问
试图读取不存在的文件
网络连接中断
数组角标越界
体系结构
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c1kGzhgu-1631633254339)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210817102901922.png)]
常见异常
异常体系结构
java.lang.Throwable |-----java.lang.Error:一般不编写针对性的代码进行处理 |-----java.lang.Exception:可以进行异常的处理 |------编译时异常(checked) |-----IOException |-----FileNotFoundException |-----ClassNotFoundException |------运行时异常(unchecked,RuntimeException) |-----NullPointerException |-----ArrayIndexOutOfBoundsException |-----ClassCastException |-----NumberFormatException |-----InputMismatchException |-----ArithmeticException
package com.atguigu.java1;import java.io.File;
import java.io.FileInputStream;
import java.util.Date;
import java.util.Scanner;import org.junit.Test;public class ExceptionTest {//******************以下是编译时异常***************************Testpublic void test7(){
// File file new File(hello.txt);
// FileInputStream fis new FileInputStream(file);
//
// int data fis.read();
// while(data ! -1){
// System.out.print((char)data);
// data fis.read();
// }
//
// fis.close();}//******************以下是运行时异常***************************//ArithmeticExceptionTestpublic void test6(){int a 10;int b 0;System.out.println(a / b);}//InputMismatchExceptionTestpublic void test5(){Scanner scanner new Scanner(System.in);int score scanner.nextInt();System.out.println(score);scanner.close();}//NumberFormatExceptionTestpublic void test4(){String str 123;str abc;int num Integer.parseInt(str);}//ClassCastExceptionTestpublic void test3(){Object obj new Date();String str (String)obj;}//IndexOutOfBoundsExceptionTestpublic void test2(){//ArrayIndexOutOfBoundsException
// int[] arr new int[10];
// System.out.println(arr[10]);//StringIndexOutOfBoundsExceptionString str abc;System.out.println(str.charAt(3));}//NullPointerExceptionTestpublic void test1(){// int[] arr null;
// System.out.println(arr[3]);String str abc;str null;System.out.println(str.charAt(0));}}
异常处理机制
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TdbyUxeH-1631633254340)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20210817150509404.png)]
抓抛模型过程一抛程序在正常执行的过程中一旦出现异常就会在异常代码处生成一个对应异常类的对象。并将此对象抛出。一旦抛出对象以后其后的代码就不再执行。关于异常对象的产生① 系统自动生成的异常对象② 手动的生成一个异常对象并抛出throw过程二抓可以理解为异常的处理方式① try-catch-finally ② throws方式一(try-catch-finally)
try-catch-finally的使用try{//可能出现异常的代码}catch(异常类型1 变量名1){//处理异常的方式1
}catch(异常类型2 变量名2){//处理异常的方式2
}catch(异常类型3 变量名3){//处理异常的方式3
}
....
finally{//一定会执行的代码
}说明
1. finally是可选的。
2. 使用try将可能出现异常代码包装起来在执行过程中一旦出现异常就会生成一个对应异常类的对象的类型去catch中进行匹配
3. 一旦try中的异常对象匹配到某一个catch时就进入catch中进行异常的处理。一旦处理完成就跳出当try-catch结构在没有写finally的情况。继续执行其后的代码
4. catch中的异常类型如果没有子父类关系则谁声明在上谁声明在下无所谓。catch中的异常类型如果满足子父类关系则要求子类一定声明在父类的上面。否则报错
5. 常用的异常对象处理的方式 ① String getMessage() ② printStackTrace()
6. 在try结构中声明的变量再出了try结构以后就不能再被调用
7. try-catch-finally结构可以嵌套体会1使用try-catch-finally处理编译时异常是得程序在编译时就不再报错但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常延迟到运行时出现。体会2开发中由于运行时异常比较常见所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常我们说一定要考虑异常的处理。
package com.atguigu.java1;import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;import org.junit.Test;public class ExceptionTest1 {Testpublic void test2(){try{File file new File(hello.txt);FileInputStream fis new FileInputStream(file);int data fis.read();while(data ! -1){System.out.print((char)data);data fis.read();}fis.close();}catch(FileNotFoundException e){e.printStackTrace();}catch(IOException e){e.printStackTrace();}}Testpublic void test1(){String str 123;str abc;int num 0;try{num Integer.parseInt(str);System.out.println(hello-----1);}catch(NumberFormatException e){
// System.out.println(出现数值转换异常了不要着急....);//String getMessage():
// System.out.println(e.getMessage());//printStackTrace():e.printStackTrace();}catch(NullPointerException e){System.out.println(出现空指针异常了不要着急....);}catch(Exception e){System.out.println(出现异常了不要着急....);}System.out.println(num);System.out.println(hello-----2);}}
finally
1.finally是可选的
2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了try中有return语句catch中有return语句等情况。
3.像数据库连接、输入输出流、网络编程Socket等资源JVM是不能自动的回收的我们需要自己手动的进行资源的 释放。此时的资源释放就需要声明在finally中。
package com.atguigu.java1;import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;import org.junit.Test;public class FinallyTest {Testpublic void test2(){FileInputStream fis null;try {File file new File(hello1.txt);fis new FileInputStream(file);int data fis.read();while(data ! -1){System.out.print((char)data);data fis.read();}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}finally{try {if(fis ! null)fis.close();} catch (IOException e) {e.printStackTrace();}}}Testpublic void testMethod(){int num method();System.out.println(num);}public int method(){try{int[] arr new int[10];System.out.println(arr[10]);return 1;}catch(ArrayIndexOutOfBoundsException e){e.printStackTrace();return 2;}finally{System.out.println(我一定会被执行);return 3;}}Testpublic void test1(){try{int a 10;int b 0;System.out.println(a / b);}catch(ArithmeticException e){e.printStackTrace();// int[] arr new int[10];
// System.out.println(arr[10]);}catch(Exception e){e.printStackTrace();}
// System.out.println(我好帅啊~~);finally{System.out.println(我好帅啊~~);}}}
方式二(throws 异常类型)
throws 异常类型写在方法的声明处。指明此方法执行时可能会抛出的异常类型。 一旦当方法体执行时出现异常仍会在异常代码处生成一个异常类的对象此对象满足throws后异常 类型时就会被抛出。异常代码后续的代码就不再执行
体会
try-catch-finally:真正的将异常给处理掉了。 throws的方式只是将异常抛给了方法的调用者。 并没有真正将异常处理掉。
开发中如何选择使用try-catch-finally 还是使用throws
1 如果父类中被重写的方法没有throws方式处理异常则子类重写的方法也不能使用throws意味着如果 子类重写的方法中有异常必须使用try-catch-finally方式处理。 2 执行的方法a中先后又调用了另外的几个方法这几个方法是递进关系执行的。我们建议这几个方法使用throws 的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。
用户自定义异常类
如何自定义异常类
继承于现有的异常结构RuntimeException 、Exception提供全局常量serialVersionUID提供重载的构造器
package com.atguigu.java2;
/** 如何自定义异常类* 1. 继承于现有的异常结构RuntimeException 、Exception* 2. 提供全局常量serialVersionUID* 3. 提供重载的构造器* */
public class MyException extends Exception{static final long serialVersionUID -7034897193246939L;public MyException(){}public MyException(String msg){super(msg);}
}
package com.atguigu.java2;public class StudentTest {public static void main(String[] args) {try {Student s new Student();s.regist(-1001);System.out.println(s);} catch (Exception e) {
// e.printStackTrace();System.out.println(e.getMessage());}}}class Student{private int id;public void regist(int id) throws Exception {if(id 0){this.id id;}else{
// System.out.println(您输入的数据非法);//手动抛出异常对象
// throw new RuntimeException(您输入的数据非法);
// throw new Exception(您输入的数据非法);throw new MyException(不能输入负数);//错误的
// throw new String(不能输入负数);}}Overridepublic String toString() {return Student [id id ];}}题目一
package com.atguigu.java2;public class ReturnExceptionDemo {static void methodA() {try {System.out.println(进入方法A);throw new RuntimeException(制造异常);} finally {System.out.println(用A方法的finally);}}static void methodB() {try {System.out.println(进入方法B);return;} finally {System.out.println(调用B方法的finally);}}public static void main(String[] args) {try {methodA();} catch (Exception e) {System.out.println(e.getMessage());}methodB();}
}
题目二
throw和throws 区别: throw表示抛出一一个异常类的对象生成异常对象的过程。声明在方法体内。 throws属于异常处理的一种方式声明在方法的声明处。
