Java基础01
无论多么艰难，都要继续前进，因为只有你放弃的那一刻，你才输了。
一、学前预备知识
1.常见cmd命令
1.盘符名称+冒号
- 说明：盘符切换
- 举例：E: 回车，表示切换到E盘
- 2.dir
- 说明：查看当前路径下的内容（包括隐藏内容）
- 3.cd目录
- 说明：进入单级目录
- 举例：cd 爱奇艺
- 4.cd..
- 说明：回退到上一级
- 5.cd 目录1\目录2\...
- 说明：进入多级目录
- 举例：cd 爱奇艺\电视剧
- 6.cd \
- 说明：回退到盘符目录
- 7.cls
- 说明：清屏
- 8.exit
- 说明：退出命令提示符窗口。
2.软件下载即配置
1.JDK目录
要着重bin目录
2.环境配置
JDK所配置的环境，仅包含了四个工具，所以要自己进行配置
1.先删掉jdk配置的环境
2.先配置JAVA_HOME。（路径不带bin）
3.再配置Path.(%IAVA_HOME%\bin)
二、基础
1.基础知识
JAVA SE JAVA语言的标准版，用于桌面应用的开发，是其他两个版本的基础。
JAVA ME java语言的小型版，用于嵌入式电子设备或者小型一定设备，现在不常用。
JAVA EE java语言的企业版，用于Web方向的网站开发。网站开发：浏览器+服务器
JAVA的主要特性：
1.面向对象 2.跨平台 3.开源 4.简单易用 5.多线程 6.安全性
java是混合型的编译运行方式
JAVA语言的跨平台是通过虚拟机实现的。
JAVA语言不是直接运行在操作系统里边的。而是运行在虚拟机中的。
针对不同的操作系统，安装不同的虚拟机就可以。
JDK(java development kit):java开发工具包 包括：
- JVM（java virtual machine）：java虚拟机，真正运行JAVA程序的地方
- 核心类库：java已经写好的东西，我们可以直接用
- 开发工具 javac 编译工具 java运行工具 jdb 调试工具….
JRE(java runtime environment):JAVA的运行环境
- JVM（java virtual machine）：java虚拟机，真正运行JAVA程序的地方
- 核心类库：java已经定义好的库
- 运行工具
2.基础概念
1.注释：
idea中的快捷键是ctrl+shift+/
- 单行注释 //
- 多行注释 /**/
- 文档注释
注释使用细节：
- 注释内容不会参与编译和运行，仅仅是对代码的解释说明
- 不管是单行注释还是多行注释，在书写的时候都不要嵌套
2.关键字：被JAVA赋予了特定涵义的英文单词
关键字特点：
- 关键字的字母全部小写
- 常用的代码编辑器，针对关键字有特殊颜色标记
class：用于创建/定义一个类，后面跟随类名
3.字面量：数据在程序中的书写格式
分类：
| 字面量类型 |
说明 |
举例 |
| 整数类型 |
不带小数点的数字 |
666，-88 |
| 小数类型 |
带小数点的数字 |
13.14 -13.12 |
| 字符串类型 |
用双引号括起来的内容 |
“Hello World”,"程序" |
| 字符类型 |
用单引号括起来的内容，内容只能有一个 |
'A','0'，'我' |
| 布尔类型 |
布尔值，表示真假 |
只有两个值：true,false |
| 空类型 |
一个特殊的值，空值 |
NULL“NULL”不能直接打印，只能以字符串的形式打印 |
特殊字符：
\t 制表符 在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补1个空格，最多补8个空格。（可以让打印的数据对齐）
4.变量：在程序执行过程中，值可能会发生改变的量
变量的定义格式
数据类型 变量名=数据值;
变量的注意事项：
1.只能存一个值
2.变量名不允许重复定义
3.一条语句可以定义多个变量
4.变量在使用之前一定要进行赋值
5.变量的作用域范围
5.计算机的存储规则
1.txt文本--数字 转二进制存储--字母、汉字 查询码表
2.Image图片--每一个像素点的RGB三原色来存储
3.Sound声音--对声音的波形图进行采样再存储
6. 数据类型
1.基本数据类型
- 如果要定义long类型的变量 在数据值的后面需要加一个L作为后缀，L可以是大写也可以是小写，推荐大写。
long n=99999L;- 如果要定义float类型的变量 在数据值的后面需要加一个F作为后缀，F可以是大写也可以是小写，推荐大写。
float f=10.1f;- double类型不用加后缀。
- 布尔类型：
-
boolean o=true; - 整数和小数取值范围大小关系：
double>float>long>int>short>byte2.引用数据类型
标识符：给类、方法、变量等起的名字
标识符命名规则--硬性要求
由数字、字母、下划线（_)和美元符（$）组成
3.IDEA下载使用
IDEA项目结构介绍
1.project 项目
2.module 模块
3.package 包
4.class 类
Eg:
微信看做 项目
下方 消息、通讯录、发现、我 可以看做四个独立的模块
以消息为例：
IDEA中的代码：
缩写:
psvm:
public static void main(String [] args){
}
sout:
System.out.println();
输出语句：
System.out.println("abc");//先打印abc再进行换行
System.out.print("abc");//只打印abc,不换行
System.out.println();//不打印任何数据，只做换行处理
System.out.printf("%s你好","张三");//用后边的字符串来填补%s，不能自动换行，输出：张三你好
System.out.printf("%s你好%s","张三","李四");//输出张三你好李四关于类的操作：
1.删除类：右键，delete
2.新创建类
3.修改类名：右键，refector,rename
关于模块：
1.新建
2.删除
3.修改
4.导入
三、语法
1.运算符
算术运算符
+ - * / %
- 有小数参与运算时，结果有可能不精确
- 整数参与运算，结果只能是整数
- 想要得到小数，要有小数参与运算
高级用法
- 数字相加
数据类型不一致，需要转成一致的才能参与运算
类型转换的分类
1.隐式转换--（自动的）
- 取值范围小的转换成取值范围大的
- Byte、short、char三种类型的数据在运算时，都会直接先提升为int，然后再进行运算
2.强制转换
- 把取值范围大的数值，赋值给取值范围小的数值
- 格式： 目标数据类型 变量名=（目标数据类型）被强转的数据；
- 字符串的“+”操作
- 当“+”操作中出现字符串时，，这个“+”是字符串连接符，而不是算术运算符了。会将前后的数据进行拼接，并产生一个新的字符串
- 连续进行“+”操作时，从左到右逐个执行
- 字符相加
- 字符+字符或者是字符+数字时，会把字符通过ASCLL码表查询到对应的数字再进行计算。
自增自减运算符
- ++、--
- ++ 、--无论放在变量前边还是放在后边，单独放一行，结果一样。
- A++ ,先用后加 ++a, 先加后用
赋值运算符
- = 赋值
- += 加后赋值 a+=b,将a+b的值给a
- -= 减后赋值 a-=b,将a-b的值给a
- *= 乘后赋值 a*=b,将a*b的值给a
- /= 除后赋值 a/=b,将a/b的商给a
- %= 取余后赋值 a%=b,将a/b的余数给a
- += -= *= /= %=底层都隐藏了一个强制类型转换
关系运算符
- 关系运算符的结果都是boolean类型
import java.util.Scanner;
public class base {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int me=sc.nextInt();
int girl=sc.nextInt();
boolean result=me>girl;
System.out.println(result);
}
}逻辑运算符
- & 逻辑与（且）---两边都满足
- | 逻辑或 ----两边满足一个
- ^ 逻辑异或-----同为false，不同为true
- ！逻辑非-----取反
短路逻辑运算符
- && 短路与---结果与单个&一样，但是具有短路效果，当左边的表达式的值可以确定最终的结果，右边就不会参与运算。
- || 短路或-----结果与|一样，但是具有短路效果，当左边的表达式的值可以确定最终的结果，右边就不会参与运算。
- 注意事项：
- & |，无论左边true false，右边都要执行。
- && ||，如果左边能确定整个表达式的结果，右边不执行。
- &&：左边为false ,右边不管是真是假，整个表达式的结果一定是false。
- ||:左边为true,右边不管是真是假，整个表达式的结果一定是true。
- 这两种情况，右边不执行，提高了效率。
三元运算符：可以进行判断，根据判断的内容来选择不同的结果
- 格式：关系表达式？ 表达式1：表达式2；
- 如果关系表达式的值为真，则输出表达式1的值，否则输出表达式2的值。
- 三元运算符的值必须要使用。
运算符优先级
- （）最高
2.判断和循环
流程控制语句
- 顺序结构
-
判断语句
-
If 格式:
- 第一种格式
-
if(关系表达式){
语句体;
}注意点：
1.大括号的开头可以另起一行书写，但最规范的是写在第一行的末尾
2.在语句体中，如果只有一句代码，大括号可以不写
3.如果对一个布尔类型的变量进行判断，可以不用写==
- 第二种格式：
if(关系表达式){
语句体;
}
else{
语句体2;
}- 第三种格式：
if(关系表达式1){ 语句体; } else if(关系表达式2){ 语句体2; } else{ 语句体n; } -
Switch
switch(表达式){ case 1: 语句体1; break; case 2: 语句体2; break; ... default: 语句体n; break; }- default的位置和省略
- default可以省略，语法不会有问题，但是不建议省略
- default可以写在任何位置，但是习惯写在最下边
- Case 穿透---语句体当中没有写break;
- 执行后没有遇到break，就不会结束整个switch，会继续往下穿透，直到遇到break或者是大括号
- switch的新特性
- Jdk12后才有
- default的位置和省略
switch(表达式){
case 1->{
//语句体1;
}
case 2->{
//语句2;
}
...
default->{
语句3;
}
}- 当每个case语句 中只用执行一句话时可以用：
switch(表达式){
case 1-> System.out.println("1");
case 2-> System.out.println("2");
...
default-> System.out.println("3");
}-
再结合case的穿透性
switch(表达式){
case 1,2-> System.out.println("2");
...
default-> System.out.println("3");
}-
循环语句
- for
- 格式：
- for
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}-
while
- 格式
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
- for和while的区别
- for循环中，控制循环的变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了。
- while循环中，控制循环的变量，对于while循环来说不归属其语法结构中，在while循环结束后，改变量还可以继续使用。
-
do ...while
- 格式
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
- 无限循环
- 格式
do{
语句体
}while(true);
for(;;){
语句体
}
while(true){
语句体
}- 跳转控制语句
- Continue 结束本次循环，继续下次循环
- Break 结束整个循环
3.数组
数组指的是一种容器，可以用来存储同种数据类型的多个值
数组容器在存储数据的时候，需要结合隐式转换考虑
数组的定义
格式1：
数据类型[] 数组名
int [] array;
格式2：
数据类型 数组名[]
int array2[];数组的初始化
- 静态初始化
格式：
完整格式：
数据类型 [] 数组名= new 数据类型[] {};
简化格式：
数据类型 [] 数组名={};int [] array1=new int[]{11,12,13,14};
int []array2={11 , 12,13,15};
String []array3=new String[]{"xioaming","xioahong"};
String []array4={"xioaming","xioahong"};数组名为数组的地址值：
public static void main(String[] args) {
System.out.println("hello world");
int []arr={1,2,3,4,5};
System.out.println(arr);//[I@6f496d9f
}1.[:表示当前是一个数组
2.I：表示当前数组里面的元素都是int类型的
3.@：表示一个间隔符号（固定格式）
4.后边的才是数组真正的地址
动态数组
数据类型 [] 数组名=new 数据类型[数组长度];数组默认初始化值的规律
1.整数类型：默认初始化为0
2.小数类型：默认初始化0.0
3.字符类型：默认初始化值'/u0000'空格
4.布尔类型：默认false
5.引用数据类型：默认NULL
四、java内存分配
1.栈：方法运行使用的内存，比如main()方法运行时，进入方法栈中执行
2.堆：存储对象或者数组，new创建出的对象都存储在堆内存
3.方法区：存储可以运行的class文件
4.本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关
5.寄存器：给CPU使用，和我们开发无关
总结：
1.只要是new出来的都在堆里面开辟了一个小空间
2.如果new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据
总结：当两个数字指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了。
五、方法：是程序中最小的执行单元
重复的代码、具有独立功能的代码可以抽取到方法中
方法的好处：
1.提高代码的复用性2.提高代码的可维护性
方法的作用：把一些代码打包在一起，用到的时候就调用
1.方法定义
方法必须先定义后调用
public static 返回值类型 方法名(参数){
方法体;
return 返回值;
}形参：全称形式参数，是指方法定义中的参数
实参：全称实际参数，方法调用中的参数
注：方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应，否则程序将报错。
方法定义的小技巧：
1.我要干什么？-----方法体
2.我干这件事情需要什么才能完成？------形参
2.方法调用
方法注意事项
1.方法不调用就不执行
2.方法与方法之间是平级关系，不能互相嵌套定义
3.方法的编写顺序和执行顺序无关
4.方法的返回值类型为void，表示该方法没有返回值，如果返回值的方法可以省略return语句不写。如果要编写return,后面不能跟具体的数据
5.return语句下面，不能编写代码，因为永远执行不到，属于无效代码
3.方法重载：在同一个类中，方法名相同，参数不同的方法。与返回值无关
参数顺序不同可以构成重载，但是不建议
基本数据类型：变量里存储的是真实的数据
引用数据类型：new出来的都是引用数据类型，变量中存储的是地址值。引用：使用其他空间的数据
练习：
1.产生验证码
import java.util.Random;
/*需求：
定义方法实现随机产生一个5位的验证码
验证码格式：
长度为5
前四位是大写或小写字母
最后一位是数字
* */
public class hellowworld {
public static void main(String[] args) {
verificationCode();
}
public static void verificationCode() {
//1.将小写字母和大写字母存数组中
char []vc=new char[52];
for(int i=0;i2.加密解密
import java.util.Scanner;
/*需求：
某系统的数字密码（大于0）比如1983，采用加密方式进行传输，
规则如下：
每位数加上5，在对10求余
最后将所有数字反转，得到一串新数
* */
public class hellowworld {
public static void main(String[] args) {
digitalEncryption();
}
public static void digitalEncryption() {
Scanner sc = new Scanner(System.in);
int password = sc.nextInt();
int copy = password, code= 0;
while (copy % 10 != 0) {
int num = copy % 10;
code = ((num + 5) % 10) +code* 10;
copy = copy / 10;
}
System.out.println(code);
}
}
六、二维数组：
数组中存数组
1.二维数组的初始化
静态初始化：
数据类型 [][]数组名=new 数据类型[][]{{元素1，元素2},{元素1，元素2}};
eg:
int [][]arr=new int[][]{{1,2},{3,4}};
简化格式：数据类型[][]数组名={{元素1，元素2},{元素1，元素2}};
eg:
int [][]arr={{11,22},{33,44}};//符合阿里巴巴代码规范
int arr[][]={{11,22},{33,44}};//也可以,但不推荐
//建议这样定义，把每一个一维数组，单独写一行
//注意：每一个一维数组其实是二维数组中的元素，
//所以每一个一维数组之间需要用逗号隔开，最后一个一维数组后面不需要加逗号
int [][]arr={
{1,2},
{3,4}
};
//二维数组的遍历
int [][]arr={
{1,2,8},
{3,4,9}
};
//外循环：遍历二维数组，得到里边的每一个一维数组
for(int i=0;i< arr.length;i++){
//内循环：遍历一维数组，得到里面的每一个元素
for(int j=0;j二维数组的动态初始化
数据类型 [][]数组名=new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组，n表示每一一维数组，可以存放多少个元素
eg:
int [][]arr=new int[2][3];二维数组的内存图
特殊情况1：初始：
赋值后：
七、面向对象
设计对象并使用
1.类和对象
类：是对像共同特征的描述
对象：是真是存在的具体东西
在java中，必须先设计类，才能获得对象。
如何定义类
定义类：
public class 类名{
1.成员变量（代表属性，一般是名词）
2.成员方法（代表行为，一般是动词）
3.构造器
4.代码块
5.内部类
}
得到类对象：
类名 对象名=new 类名（）;
使用方法：
访问属性：
对象名.成员变量
访问行为：
对象名。方法名（...）
eg:
public class Phone {
//属性（成员变量）
String brand;
double prices;
//行为（方法）
public void call(){
System.out.println("手机在打电话");
}
public void playGame(){
System.out.println("手机在玩游戏");
}
}
//测试类
public class PhoneTest {
//创建对象
public static void main(String[] args) {
Phone p=new Phone();
p.brand="小米";
p.prices=199.86;
System.out.println(p.brand);
System.out.println(p.prices);
p.playGame();
p.call();
}
}类的几个补充注意事项
1.用来描述一类事物的类，专业叫做：Javabean类。
在Javabean类中，不写main方法。
2.编写main方法的类，叫做测试类
我们可以在测试类中创建javabean类的对象并进行赋值调用。
3.类名首字母建议大写，需要见名知义，驼峰模式
4.一个java文件可以定义多个class类，且只能一个类时public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类
5.成员变量的完整定义格式是： 修饰符 数据类型 变量名称 =初始化值;一般无需指定初始化值，存在默认值。
对象的成员变量的默认值规则：
开发中类的设计
可以提取名词--》属性
可以提取动词--》行为
2.封装
告诉我们：如何正确设计对象的属性和方法。
原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为
eg: 人关门
关门这个方法是门的方法。
private关键字
- 是一个权限修饰符
- 可以修饰成员（成员变量和成员方法）
- 被private修饰的成员只能在本类中才能访问
- 针对private修饰的成员变量，如果需要被其他类使用，必须提供相应的操作
- 提供“setXxx(参数)”方法，用于给成员变量赋值，方法用public修饰
- 提供“getXxx()”方法，用于获取成员变量的值，方法用public修饰
public class girlFriend {
private String name;
private int age;
//针对每一个私有化的成员变量，都要提供get和set方法
//name
public void setName(String name) {
this.name = name;
}
public String getName(){
return name;
}
//age
public void setAge(int age){
if(age>0&&age<=100)
this.age=age;
else
System.out.println("非法输入");
}
public int getAge(){
return age;
}
public void sleep(){
System.out.println("女朋友在睡觉");
}
}
//测试类
public class girlFriendTest {
public static void main(String[] args) {
girlFriend gf=new girlFriend();
gf.setName("Сʫʫ");
gf.setAge(-1);
System.out.println(gf.getName());
System.out.println(gf.getAge());
gf.sleep();
}
}
局部变量和成员变量
局部变量和成员变量重名是按照就近原则，要用成员变量就用 “this. +成员变量”
this的作用：区别成员变量和局部变量
3.构造方法
也叫构造器、构造函数
作用：在创建对象的时候，由虚拟机自动调用，给成员变量进行初始化
构造方法有：
1.无参数构造方法：初始化对象时，成员变量的数据均采用默认值
2.有参数构造方法：初始化对象时，同时给成员变量赋值
格式：
修饰符 类名(参数){
方法体;
}特点：
1.方法名与类名相同，大小写也要一致
2.没有返回值类型，连void也没有
3.没有具体的返回值（不能由return带回结果数据）
执行时机：
1.创建对象的时候由虚拟机调用，不能手动调用构造方法
2.每创建一次对象，就会调用一次构造方法
构造方法注意事项：
1.构造方法的定义：
- 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
- 如果定义了构造方法，系统将不提供默认的构造方法
2.构造方法的重载
- 带参构造方法，和无参数构造方法，两者方法名相同，但是参数不同，这叫构造方法的重载
3.推荐使用方法
- 无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法
八、标准的JavaBean
- 类名需要见名知意，驼峰命名
- 成员变量使用private修饰
- 至少提供两个构造方法
- 无参构造方法
- 带全部参数的构造方法
- 成员方法
- 提供每个成员变量对应的setX()/getX()
- 如果还有其他行为，也需要写上
package test01;
public class girlFriend {
private String name;
private String password;
private int age;
//无参构造方法
public girlFriend() {
}
//有全部参数的构造方法
public girlFriend(String name, String password, int age) {
this.name = name;
this.password = password;
this.age = age;
}
//name
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//password
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
//age
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}对象内存图
一个对象的内存图：
在study()方法使用完后，study方法出栈，程序结束，main()方法也出栈，之后堆内存中会被回收
两个对象的内存图
两个引用指向同一个对象：当两个引用其中一个对这个对象的内容进行改变后，另一个引用再次访问时，就是改变后的值。
stu1=NULL:
基本数据类型和引用数据类型
基本数据类型：数据值是存储在自己的空间中
特点：赋值给其他变量，赋的真实的值
引用数据类型：数据值是存储在其他空间中，子集空间中存储的是地址值
特点：赋值给其他变量，赋的是地址。
this的内存原理：
this的本质：代表方法调用者的地址值
成员变量和局部变量
成员变量：类中方法外的变量
局部变量：方法中的变量
九、API与字符串
API（Application Programming Interface）:应用程序编程接口
简单理解：API就是别人已经写好的东西，我们不需要自己编写，直接使用即可。
java API ：指的就是jdk中提供的各种功能的java类
这些类将底层的实现封装了起来，我们不需要关心这些类时如何实现的，只需要学习这些类如何使用即可
API帮助文档：帮助开发人员更好使用和查询API的一个工具
使用方法：
1.打开API帮助文档
2.点击显示，并找到索引下面的输入
3.在输入框中输入类名并点击显示
4.查看类所在的包
5.查看类的描述
6.查看构造方法
7.查看成员方法
字符串
1.java.lang.String类代表字符串，java程序中的所有字符串文字都为此类的对象。
使用时不用导包。
2.字符串的内容是不会发生改变的，它的对象在创建后不能被更改。
String name="哈哈";
name="你好";
System.out.println(name);
//实际创建了两个对象
String name="哈哈";
dongzuo="你好";
System.out.println(name+dongzuo);
/实际创建了三个对象构造方法
1.直接赋值
//直接赋值方式获得一个字符串对象(用的最多)
String s1 = "abc";
System.out.println(s1);//abc2.new
//使用new的方式来获取一个字符串对象（相当于“”）
String s2=new String();
System.out.println("你好"+s2+"不好");//你好不好
//传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象（很少使用）
String s3=new String("abcd");//abcd
System.out.println(s3);
//传递一个字符数组，根据字符数组的内容再创建一个新的字符串对象
//需求：修改字符串内容
//abc--->{'a','b','c'}---->{'Q','b','c'}----->"Qbc"
char []chs={'a','b','c'};
String s4=new String(chs);//abc
System.out.println(s4);
//传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
//应用场景：以后在网络当中传输的数据其实都是字节信息
//我们一般要把字节信息进行转换，转成字符串，此时就要用到这个构造了
byte[] bytes={97,98,99};
String s5=new String(bytes);
System.out.println(s5);//abc
内存模型：String Table(串池)在jdk7版本开始从方法区挪到了堆内存
直接赋值：--节约内存-代码最简单
当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在。不存在：创建新的；存在：复用。
用new创建字符串对象：
常用方法：
1.比较
==号比的到底是什么？
字符串比较--比较内容
String s1 = "abc";
String s2 = new String("abc");
//==号比较
System.out.println(s1 == s2);//false
//比较字符串对象中的内容是否相同
boolean result1 = s1.equals(s2);
System.out.println(result1);//true
String s3 = new String("Abc");
boolean result2 = s1.equals(s3);
System.out.println(result2);//false
boolean result3 = s1.equalsIgnoreCase(s3);
System.out.println(result3);//true
结论：
以后只要想比较字符串的内容，就必须要用String里面的方法
练习：
//1.键盘录入一个abc
Scanner sc=new Scanner(System.in);
String s1=sc.next();//abc 是new出来的
//2.代码中在定义一个字符串abc
String s2="abc";
//3.用==比较，这两者能一样吗？
System.out.println(s1==s2);//false
//结论：
//以后只要想比较字符串的内容，就必须要用String里面的方法
录入一个字符串，并遍历
//键盘录入一个字符串，并遍历
Scanner sc=new Scanner(System.in);
String s=sc.next();
for(int i=0;i金额转换：
public static void main(String[] args) {
//1.键盘录入一个金额
Scanner sc=new Scanner(System.in);
int money;
while(true){
System.out.println("请录入一个金额：");
money=sc.nextInt();
if(money>=0&&money<=9999999){
break;
}
else{
System.out.println("金额无效！");
}
}
//定义一个变量用来表示钱的大写
String moneyStr=MoneyStr(money);
System.out.println(moneyStr);
}
//对money进行变换
public static String MoneyStr(int money) {
String []CapitalNumber={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
String []DanWei={"佰","拾","万","仟","佰","拾","元"};
String moneyStr="";
//2.得到money里面每一位数字，再转成中文
while(money!=0){
int ge=money%10;
moneyStr=CapitalNumber[ge]+moneyStr;
money=money/10;
}
//3.补齐七位数
int cout=7-moneyStr.length();
for(int i=0;i- String substring(int beginindex,int endindex) 截取
- 注意点：包头不包尾，包左不包右。只有返回值才是截取的小串。
- String substring(int beginindex) 截取到末尾
- charAt() 返回一个字符串的指定位置的字符，索引是从[0,length-1].比如：
- str.charAt(0)检索str中的第一个字符,str.charAt(str.length()-1)检索最后一个字符。
//从身份证中获取信息
String id="41138120060510302X";
String year=id.substring(6,10);
String month=id.substring(10,12);
String day=id.substring(12,14);
System.out.println("人物信息为：");
System.out.println("出生年月日："+year+"年"+month+"月"+day+"日");
//获取性别
char gender=id.charAt(16);//'3'
int num=gender-48;
if(num%2==0){
System.out.println("性别为：女");
}else{
System.out.println("性别为：男");
}
- String.replace(char oldchar,char newchar) 替换
String num = "1,2,3";
String[] arr = {"1","2","4"};
for(int i=0;i十、StringBuilder和StringJoiner概述
StringBuilder概述
使用场景：
1.字符串的拼接
2.字符串的反转
StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的
- 作用：提高字符串的操作效率
构造方法：
- public StringBuilder() 创建一个空白可变的字符串对象，不含有任何内容
- public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象
StringBuilder常用的方法
- public StringBuilder append(任意类型) 添加数据，并返回对象本身
- public StringBuilder reverse() 反转容器中的内容
- pubilc int length() 返回长度（字符出现的个数）
- public String toString() 通过toString就可以实现把StringBuilder转换成String
注意：
因为StringBuilder是java已经写好的类，java在底层对他做了一些特殊处理，打印对象不是地址值而是属性值。
StringBuilder sb = new StringBuilder("ABC");
sb.append("123");
sb.reverse();
System.out.println(sb);
String str = sb.toString();
System.out.println(str);
链式编程：当我们在调用一个方法的时候，不需要用变量接收他的结果们可以继续调用其他方法。
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str=sc.next();
//反转键盘录入的字符串
String result=new StringBuilder().append(str).reverse().toString();
if(str.equals(result)){
System.out.println("是反转字符串");
}else{
System.out.println("不是反转字符串");
}
StringJoiner概述
StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。
作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用。
JDK8出现的一个可变的操作字符串的容器，可以高效，方便的拼接字符串。
构造方法：
- Public StringJoiner(间隔符号) 创建一个StringJoiner对象，指定拼接时的间隔符号
- Public StringJoiner(间隔符号，开始符号，结束符号) 创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号。
- public StringJoiner add(添加的内容) 添加数据，并返回对象本身
- Public int length()返回长度（字符出现的个数）
- public String toString() 返回一个字符串（该字符串就是拼接之后的结果）
StringJoiner sj=new StringJoiner(",","[","]");
sj.add("aaa").add("bbb").add("ccc");
System.out.println(sj);
原理扩展
字符串原理
扩展底层原理1：字符串存储的内存原理
- 直接赋值会复用字符串常量池中的
- new出来不会复用，而是开辟一个新的空间
扩展底层原理2：==号比较的到底是什么
- 基本数据类型比较数据值
- 引用数据类型比较地址值
扩展底层原理3：字符串拼接的底层原理
如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果
如果有变量参与，会创建新的字符串，浪费内存
拼接时右边无变量：
拼接时右边有变量：
扩展底层原理4：StringBuilder提高效率原理图
所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存
常见面试题
扩展底层原理5：StringBuilder源码分析
- 默认创建一个长度为16的字节数组
- 添加的内容长度小于16，直接存
- 添加的内容大于16会扩容（原来的容量*2+2）
- 如果扩容之后还不够，以实际长度为准
练习：
1.罗马数字转换
package test02;
import java.util.Scanner;
public class hellowworldTest {
public static void main(String[] args) {
String str;
while (true) {
//1.录入字符串
System.out.println("请输入一个字符串：");
Scanner sc=new Scanner(System.in);
str=sc.next();
//2.判断字符串是否符合要求
boolean request=Judge(str);
if(request){
break;
}else{
System.out.println("当前的字符串不符合要求");
continue;
}
}
// //3.用罗马数字进行拼接
// str=Replace(str);
// System.out.println(str);
StringBuilder sb=new StringBuilder();
for(int i=0;i"";
case '1'->"Ⅰ";
case '2'->"Ⅱ";
case '3'->"Ⅲ";
case '4'->"Ⅳ";
case '5'->"Ⅴ";
case '6'->"Ⅵ";
case '7'->"Ⅶ";
case '8'->"Ⅷ";
case '9'->"Ⅸ";
default -> str="" ;
};
return str;
}
// public static String Replace(String str){
// char [] luoma={' ','Ⅰ','Ⅱ','Ⅲ','Ⅳ','Ⅴ','Ⅵ','Ⅶ','Ⅷ','Ⅸ'};
// for(int i=0;i9){
return false;
}
for(int i=0;i'9'){
return false;
}
}
return true;
}
}
str.toCharArray() 将字符串转换为字符数组。
package test02;
public class hellowworldTest {
public static void main(String[] args) {
//套路：
//修改字符串的内容
//1.用substring进行截取，把左边的字符截取出来拼接到右侧去
//2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串
String strA = "abcde";
String strB = "cefab";
//1.旋转字符串，并比较
int i = 0;//记录比较次数
while (!strA.equals(strB) && i < strA.length()) {
strA = rotate(strA);
i++;
// System.out.println(strA+" "+i);
}
if (strA.equals(strB)) {
System.out.println("TRUE");
} else {
System.out.println("FALSE");
}
}
//作用：旋转字符串，将左边字符串旋转到右边去
//形参：旋转前的字符串
//返回值：旋转后的字符串
public static String rotate(String str) {
// //1.用substring截取
// char first = str.charAt(0);
// String end = str.substring(1);
// return end + first;
//2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串
//"ABC" ['A','B','C']
char[] arr = str.toCharArray();
//拿到0索引上的字符
char first = arr[0];
//把剩余的字符依次往前挪一个位置
for (int i = 1; i < arr.length; i++) {
arr[i - 1] = arr[i];
}
arr[arr.length - 1] = first;
//利用字符数组创建一个字符串对象
String result = new String(arr);
return result;
}
}
十一、集合
自动扩容
集合存储数据类型的特点：只能存引用数据类型，基本数据类型存储时要变成包装类
ArrayList
在java.util包下，需要导包
泛型：限定集合中存储数据的类型
ArrayList list=new ArrayList<>();
//此时我们创建的是ArrayList的对象，而ArrayList是java已经写好的一个类
//这个类在底层做了一些处理
// 打印对象不是地址值，而是集合中存储的数据内容
// 在展示的时候会拿[]把所有的数据进行包裹
System.out.println(list);//[] ArrayList成员方法
//1.创建一个对象
ArrayList list = new ArrayList<>();
//2.添加元素--返回值是true
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("bbb");
// //3.删除元素
// boolean result1 = list.remove("aaa");
// System.out.println(result1);//true
//
// boolean result2 = list.remove("eee");//删除内容不存在，删除失败
// System.out.println(result2);//false
// //3.根据索引删除
//
// String str = list.remove(2);//返回被删除的字符串
// System.out.println(str);//ddd
// //4.修改
// String str = list.set(1, "eee");//返回被覆盖的元素
// System.out.println(str);//bbb
//5.查询
// String str=list.get(1);
// System.out.println(str);//bbb
//遍历--list.fori
for (int i = 0; i < list.size(); i++) {
String str= list.get(i);
System.out.print(str+" ");//aaa bbb ccc ddd bbb
}
System.out.println(list); 集合练习：
集合存入String和int类型
// ArrayList list=new ArrayList<>();
//
// list.add("aaa");
// list.add("aaa");
// list.add("aaa");
// list.add("aaa");
// list.add("aaa");
//
// System.out.print("[");
// for (int i = 0; i < list.size(); i++) {
// if(i== list.size()-1){
// System.out.print(list.get(i));
// }else{
// System.out.print(list.get(i)+",");
// }
// }
// System.out.print("]");
ArrayList list=new ArrayList<>();
list.add(1);
list.add(1);
list.add(1);
list.add(1);
list.add(1);
System.out.println(list);
集合存入自定义类
Scanner sc=new Scanner(System.in);
ArrayList list=new ArrayList<>();
for(int i=0;i<3;i++){
girlFriend gf=new girlFriend();
System.out.println("请输入姓名：");
String name=sc.next();
gf.setName(name);
System.out.println("请输入年龄：");
int age=sc.nextInt();
gf.setAge(age);
list.add(gf);
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName()+" "+list.get(i).getAge());
}
package test01;
import java.util.ArrayList;
public class girlFriendTest {
public static void main(String[] args) {
//定义集合
ArrayList list=new ArrayList<>();
//存入三个对象
girlFriend gf1=new girlFriend("小米",1000);
girlFriend gf2=new girlFriend("苹果",8000);
girlFriend gf3=new girlFriend("锤子",2999);
list.add(gf1);
list.add(gf2);
list.add(gf3);
ArrayList gfInFoList=judgePrice(list);
for (int i = 0; i < gfInFoList.size(); i++) {
girlFriend gf=gfInFoList.get(i);
System.out.println(gf.getBrand()+" "+gf.getPrice());
}
}
//返回价格低于3000的手机信息
//技巧：
//如果我们要返回多个数据，可以把这些数据放在一个容器里，再把容器返回
//集合 数组
public static ArrayList judgePrice(ArrayList list){
ArrayList resultList=new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
girlFriend gf=list.get(i);
int price=gf.getPrice();
if(price<3000){
resultList.add(gf);
}
}
return resultList;
}
}
十二、面向对象进阶
static
static表示静态，是java中的一个修饰符，可以修饰成员方法，成员变量
被static修饰的成员变量，叫做静态变量
特点：
- 被该类所有对象共享
- 不属于对象，属于类
- 随着类的加载而加载，优先于对象存在
调用方法：
- 类名调用（推荐）
- 对象名调用
被static修饰的成员方法，叫做静态方法。
- 多用在测试类和工具类中
- javabean类中很少会使用
工具类：帮助我们做一些事情的，但是不描述任何事物的类
- 类名见名知意
- 私有化构造方法
- 方法定义为静态
javabean类：用来描述一类事物的类
测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口
package staticdemo1;
public class ArrayUtil {
//私有化构造方法
//目的：为了不让外界创建他的对象
private ArrayUtil(){}
//需要定义为静态的，方便调用
public static String printArr(int []arr){
StringBuilder sb=new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
sb.append(arr[i]);
}else{
sb.append(arr[i]).append(",");
}
}
sb.append("]");
return sb.toString();
}
public static double getAverage(double[]arr){
double sum=0;
for (int i = 0; i < arr.length; i++) {
sum=sum+arr[i];
}
return sum/arr.length;
}
}
---------------------------------------------------------------------
package staticdemo1;
public class TestDemo1 {
public static void main(String[] args) {
int []arr1={1,2,3,4,5};
String s=ArrayUtil.printArr(arr1);
System.out.println(s);
double []arr2={12.5,13.5,45.2,12.5,12.3};
double end=ArrayUtil.getAverage(arr2);
System.out.println(end);
}
}
static的注意事项
- 静态方法只能访问静态变量和静态方法
- 非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法、静态方法中没有this关键字
继承
java中提供一个关键字extend，用这个关键字，我们可以让一个类和另一个类建立起起继承关系。
public class 子类 extends 父类{}
eg：
public class Student extends Person{}Student称为子类（派生类），Person称为父类（基类或超类）。
使用继承的好处：
- 可以把多个子类中重复的代码抽取到中，提高代码的复用性。
- 子类可以在父类的基础上，增加其他的功能，使子类更强大。
当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑继承，来优化代码。
继承的特点：
- java只支持单继承，不支持多继承，但支持多层继承。
- 单继承：一个子类只能有一个父类。
- 不支持多继承：子类不能同时继承多个父类。
- 多层继承：子类A继承父类B，父类B可以继承父类C。
- 每一个类都直接或者间接的继承与Object。
子类只能访问父类中非私有的成员。
子类能继承父类哪些内容？
构造方法：
继承中成员变量和成员方法的访问特点：
成员变量的访问特点：
就近原则：谁离我近我就用谁
先局部位置--再本类的成员位置---后父类成员位置，一级一级往上找
成员方法的访问特点：
直接调用满足就近原则：谁离我近，我就用谁
super调用，直接访问父类
方法的重写
当父类的方法不能满足子类现在的需求时，需要进行方法重写。
书写格式：在继承体系中，子类出现了和父类中一模一样的方法声明，我们就成称子类这个方法是重写的方法。
@Override重写注解
1.@Override是放在重写后的方法上，校验子类重写时语法是否正确。
2.加上注解后如果有红色波浪线，表示语法错误。
3.建议重写方法都加@Override注解，代码安全，优雅！
方法重写注意事项和要求：
1.重写方法的名称、形参列表必须与父类中的一致。
2.子类重写父类方法时，访问权限子类必须大于等于父类（暂时了解：空着不写 3.子类重写父类方法时，返回值类型子类必须小于等于父类。 4.建议：重写的方法尽量和父类保持一致 5.只有被添加到虚方法表中的方法才能被重写 this、super使用总结： 什么是多态？ 同类型的对象，表现出不同形态，对象的多种形态 多态的表现形式 多态的前提 多态调用成员的特点 调用成员变量：编译看左边，运行也看左边 编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。 运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值。 调用成员方法：编译看左边，运行看右边 编译看左边：javac编译代码的时候。会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。 运行看右边：java运行代码的时候，实际上运行的是子类中的方法。 成员变量：在子类的对象中，会把父类的成员变量也继承下的。 成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的 多态的优缺点 引用数据类型的类型转换，有几种方式？ 自动类型转换、强制类型转换 强制类型转换能解决什么问题？ 什么是包？ 包就是文件夹。用来管理各种不同功能的java类，方便后期维护代码维护。 包名的规则：公司域名反写+包的作用，需要全部英文小写，见名知意。 全类名/全限定名 包名+类名 eg: 使用其他类的规则 使用其他类时，需要使用全类名 可以修饰方法、类、变量。 方法：表明该方法时最终方法，不能被重写 类：表明该类是最终类，不能被继承 变量：叫做常量，只能被赋值一次 常量 实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性 常量的命名规范： 细节： final修饰的变量是基本类型：那么变量存储的数据值不能发生改变 final修饰的变量是引用类型：那么变量存储的是地址值不能发生改变，对象内部的可以改变。 有四种作用范围：由小到大： private<空着不写（默认） 实际开发中，一般只用private和public 使用时一般： 特例：如果方法中的代码时抽取其他方法中共性代码，这个方法一般也私有。 局部代码块 写在方法里面的代码块 构造代码块 1.写在成员位置的代码块 2.作用：可以把多个构造方法中的重复代码抽取出来 3.执行时机：我们在创建本类对象的时候会先执行构造代码块在执行构造方法 渐渐淘汰了，不够灵活 如果构造方法中有重复代码，可以用以下两种方法： 静态代码块 格式：static{ } 特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次。 使用场景：在类加载的时候，做一些数据初始化且这些数据初始化只想使用一次的时候使用。 将共性的行为（方法）抽取到父类之后。由于每一个子类执行的内容是不一样，所以，再父类中不能确定具体的方法体。该方法就可以定义为抽象方法。 抽象方法的定义格式： public abstract 返回值类型 方法名（参数列表); 抽象类的定义格式： public abstract class 类名 {} 抽象类和抽象方法的注意事项： 强制子类必须按照这种格式书写 接口就是一种规则，是对行为的一种抽象 接口和抽象类：抽象类多用在父类中 格式： 例子： 只能是常量 默认修饰符：public static final ... 没有 只能是抽象方法 默认修饰符：public abstract 例子： JDK7以前：接口中只能定义抽象方法。 JDK8的新特性：接口中可以定义有方法体的方法（默认、静态）。 JDK9的新特性：接口中可以定义私有方法。 简单理解：设计模式就是各种套路 适配器设计模式：解决接口与接口实现类之间的矛盾问题 当一个接口中抽象方法过多，但是我只要使用其中一部分的时候，就可以用适配器设计模式。 2.书写步骤： 编写中间类xxxAdapter,实现对应的接口 对接口中的抽象方法进行空实现 让真正的实现类继承中间类，并重写需要用的方法 为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰。 类的五大成员： 属性、方法、构造方法、代码块、内部类 内部类：在一个类的内部再定义一个类,这个类称为内部类 内部类的访问特点： 1.内部类可以直接访问外部类的成员，包括私有 2.外部类要访问内部类的成员，必须创建对象。 什么时候用到内部类？ B类表示的事物是A类的一部分，且B单独存在没有意义。 成员内部类、静态内部类、局部内部类（前三个了解）和匿名内部类（掌握）。 方法一：在外部类中编写方法，对外提供内部类的对象。----当成员内部类被private修饰时 方法二：直接创建格式：--------当成员内部类被非私有修饰时 外部类名.内部类名 对象名=外部类对象.内部类对象 外部类成员变量与内部类成员变量重名时，在内部类如何访问？ 外部类名.this.变量名 静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象 创建静态内部类对象的格式：外部类.内部类 对象名=new 外部类名.内部类名（）； 调用非静态方法的格式：先创建对象，用对象调用 调用静态方法的格式：外部类名.内部类名.方法名（）； 匿名内部类本质上就是隐藏了名字的内部类 什么是匿名内部类？ 隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置。 格式的细节： 包含了继承或实现关系、方法重写、创建对象。 整体就是一个类的子类对象或者接口的实现对象 使用场景： 当方法的参数是接口或者类时， 以接口为例，可以传递这个接口的实现类对象 如果实现类只要使用一次，就可以用匿名内部类简化代码。 格式： 注意： 阶段项目 事件是可以被组件识别的操作。 当你对组件干了某件事情之后，就会执行对应的代码。 事件源：按钮 图片 窗体..... 事件：某些操作 如：鼠标单击，鼠标划入... 绑定监听：当事件源上发生了某个事件，则执行某段代码 KeyListener MouseListener ActionListener 键盘监听 鼠标监听 动作监听（鼠标左键点击和空格） 1.导包 import java.util.Random; 导包的动作必须出现在类定义的上边。 2.创建对象---表示要是开始用Random这个类了 Random r=new Random; 上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。 3.生成随机数---真正开始干活了 Int number=r.nextint(随机数的范围)； 上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。 判断范围： 在小括号内，书写的是生成随机数的范围，范围是从0开始的，到数-1结束 口诀：包头不包尾，包左不包右 Ctrl+alt+l 格式化代码，让代码变齐 Ctrl+/ 单行注释或解除注释 Ctrl+shift+/ 多行注释或解除注释 按住鼠标滚轮 或者 按住alt 不松，再拖动，可以同时修改选中的代码 alt+insert 可选constructor设置构造方法和选Getter and Setter 来设置setX,getX 或者安装ptg插件后，右键导入javabean. Ctrl +alt+v 自动生成左边 对于数组用for循环遍历时，可以用 对一串代码加循环，选中要加循环的代码后按ctrl+alt+t 选住后按shift+f6 批量修改 选中方法，ctrl+b跟进 ctrl+z 撤销操作继承中构造方法的访问特点
package staticdemo1;
public class TestDemo1 {
public static void main(String[] args){
Student s1=new Student();
//输出：父类的无参构造
// 子类的无参构造
Student s2=new Student("张三",16);
System.out.println(s2.name+" "+s2.age);//输出：张三 16
}
}
class Person{
String name;
int age;
public Person() {
System.out.println("父类的无参构造");
}
public Person(String name,int age) {
this.name = name;
this.age=age;
}
}
class Student extends Person{
public Student() {
//子类中隐藏的super去访问父类的无参构造
System.out.println("子类的无参构造");
}
public Student(String name, int age) {
super(name, age);//调用父类的有参构造
}
}
package staticdemo1;
public class TestDemo1 {
public static void main(String[] args){
Student s1=new Student();
System.out.println(s1.name+" "+s1.age+" "+s1.school);//null 0 传智大学
Student s2=new Student("张三",16,"黑马");
System.out.println(s2.name+" "+s2.age+" "+s2.school);//张三 16 黑马
}
}
class Person{
String name;
int age;
public Person() {
System.out.println("父类的无参构造");
}
public Person(String name,int age) {
this.name = name;
this.age=age;
}
}
class Student extends Person{
//需求：
//默认为传智大学
String school;
public Student() {
//表示调用本类的其他构造方法；
//细节：虚拟机就不会再添加super()方法。因为其他构造中有
this(null,0,"传智大学");
}
public Student(String name, int age,String school) {
super(name,age);
this.school=school;
}
}
多态
父类类型 对象名称=子类对象;
package staticdemo1;
public class test {
public static void main(String[] args) {
Animal a=new dog();
//类型强转
//方法·1
// if(a instanceof dog){
// dog d=(dog)a;
// d.LookHome();
// }else if(a instanceof cat){
// cat c=(cat)a;
// c.CatchMouse();
// }else{
// System.out.println("没有这个类型，无法转换");
// }
//方法2
if(a instanceof dog d){
d.LookHome();
}else if(a instanceof cat c){
c.CatchMouse();
}else{
System.out.println("没有这个类型，无法转换");
}
}
}
package staticdemo1;
public class test {
public static void main(String[] args) {
Animal a=new cat(3,"灰");
person p=new person("老王",30);
p.keepPet(a,"小鱼干");
Animal a2=new dog(2,"黑");
person p2=new person("老李",25);
p2.keepPet(a2,"骨头");
}
}
-----------------------------------------------------
package staticdemo1;
public class Animal {
//属性
private int age;
private String color;
public Animal() {
}
public Animal(int age, String color) {
this.age = age;
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat(String something){
if(this instanceof dog d){
d.eat(something);
}else if(this instanceof cat c){
c.eat(something);
}
}
}
---------------------------------------------
package staticdemo1;
public class cat extends Animal{
public cat() {
}
public cat(int age, String color) {
super(age, color);
}
public void catchMouse(){
System.out.println("猫逮老鼠");
}
@Override
public void eat(String something) {
System.out.println(getAge()+"岁的"+getColor()+"颜色的猫眯着眼睛侧着头吃"+something);
}
}
----------------------------------------------
package staticdemo1;
public class dog extends Animal{
public dog() {
}
public dog(int age, String color) {
super(age, color);
}
public void lookHome(){
System.out.println("狗看家");
}
@Override
public void eat(String something) {
System.out.println(getAge()+"岁的"+getColor()+"颜色的狗两只前腿死死的抱住"+something+"猛吃");
}
}
----------------------------------------------------------------
package staticdemo1;
//饲养员
public class person {
private String name;
private int age;
public person() {
}
public person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//行为
public void keepPet(Animal a,String something){
System.out.print("年龄为"+getAge()+"岁的"+getName()+"养了一只"+a.getColor()+"颜色的"+a.getAge()+"岁的");
if(a instanceof dog d){
System.out.println("狗");
d.eat(something);
}else if(a instanceof cat c){
System.out.println("猫");
c.eat(something);
}
}
}
final--最终的
private static final PI="3.14159";权限修饰符
权限修饰符的分类：
权限修饰符使用规则
代码块
抽象类与抽象方法
package test05;
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public void drink(){
System.out.println("动物在喝水");
}
public abstract void eat();
}
------------------------------------------------------------
package test05;
public class Sheep extends Animal{
public Sheep() {
}
public Sheep(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("山羊吃草");
}
}
抽象方法和抽象类的意义
接口
public class 子类g extends 父类 implements 接口1,接口2....{
....
}package test05;
public interface swim {
public abstract void swim();
}
------------------------------------------
package test05;
public class Dog extends Animal implements swim{
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void swim() {
System.out.println("狗在游泳");
}
}
接口中成员的特点
接口和类之间的关系
package test05;
public class InterImp1 implements Inter3{
@Override
public void method1() {
}
@Override
public void method2() {
}
@Override
public void method3() {
}
}
----------------------------------------------------
package test05;
public interface Inter3 extends Inter1, Inter2{
public abstract void method3();
}
-------------------------------------------------------
package test05;
public interface Inter2 {
public abstract void method2();
}
-----------------------------------------------------
package test05;
public interface Inter1 {
public abstract void method1();
}
JDK8开始接口中的新增方法
package test05;
public interface Inter1 {
public static void show1(){
System.out.println("Inter中的静态方法");
}
}
---------------------------------------------
package test05;
public class InterImp1 implements Inter1{
//不叫重写，只是这两个接口中的静态方法同名而已
public static void show1(){
System.out.println("InterImp1中的静态方法");
}
}
---------------------------------------------
package test05;
public class Test {
public static void main(String[] args) {
InterImp1 i1 =new InterImp1();
i1.show();
//调用接口中的静态方法
InterImp1.show1();//Inter中的静态方法
//调用实现类中的静态方法
InterImp1.show1();//InterImp1中的静态方法
//子类把父类继承下来的虚方法表里面的方法进行覆盖了，这才叫做重写
}
}
JDK9新增的方法--解决重复代码
package test06;
public interface InterA {
public default void show1(){
System.out.println("show1方法开始执行了");
show3();
}
public default void show2(){
System.out.println("show2方法开始执行了");
show3();
}
//普通的私有方法
private void show3(){
System.out.println("这里有100行show1,show2的重复代码");
}
public static void show4(){
System.out.println("show1方法开始执行了");
show6();
}
public static void show5(){
System.out.println("show2方法开始执行了");
show6();
}
//静态的私有方法
private static void show6(){
System.out.println("这里有100行show4,show5的重复代码");
}
}
接口的应用
适配器设计模式
内部类
内部类的分类
成员内部类
获取成员内部类对象
package test07;
public class Out {
String name;
private class Inner{
}
public Inner getInstance(){
return new Inner();
}
}
-----------------------------------------------
package test07;
public class Test {
public static void main(String[] args) {
//是否能用与内部类的权限修饰符有关
// Out.Inner oi=new Out().new Inner();
Out o=new Out();
System.out.println(o.getInstance());
}
}
静态内部类
package test07;
public class Car {
int a=10;
static int b=20;
//静态内部类
static class Inner {
public void show1(){
//要访问a,需要创建对象
Car c=new Car();
System.out.println(c.a);
//b可以直接访问
System.out.println(b);
//System.out.println("非静态方法被调用了");
}
public static void show2(){
//要访问a,需要创建对象
Car c=new Car();
System.out.println(c.a);
//b可以直接访问
System.out.println(b);
//System.out.println("静态方法被调用了");
}
}
}
package test07;
public class Car {
int a=10;
static int b=20;
//静态内部类
static class Inner {
public void show1(){
System.out.println("非静态方法被调用了");
}
public static void show2(){
System.out.println("静态方法被调用了");
}
}
}
----------------------------
package test07;
public class Test {
public static void main(String[] args) {
//创建静态内部类的对象
//只要是静态的东西，都可以用类名之间获取
Car.Inner ci=new Car.Inner();
ci.show1();
//静态方法
//用ci.show2()也可以，但是不推荐
Car.Inner.show2();
}
}
局部内部类
package test07;
public class Car {
int a=10;
public void show(){
int b=20;
//局部内部类
class Inner{
String name;
int age;
public void method1(){
System.out.println(a);
System.out.println(b);
System.out.println("局部内部类中的method1方法");
}
public static void method2(){
System.out.println("局部内部类中的method2静态方法");
}
}
//创建局部内部类的对象
Inner i=new Inner();
System.out.println(i.age);
System.out.println(i.name);
i.method1();
Inner.method2();
}
}
--------------------------------------------------------------
package test07;
public class Test {
public static void main(String[] args) {
//创建对象，调用show方法
Car c=new Car();
c.show();
}
}
----------------
//输出
0
null
10
20
局部内部类中的method1方法
局部内部类中的method2静态方法
匿名内部类（重要）
new 类名或者接口名(){
重写方法;
};
eg：
new Inter(){
public void show(){
}
}
package test07;
public abstract class Animal {
public abstract void eat();
}
--------------------------------
package test07;
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("重写eat抽象方法");
}
}
--------------------------------
package test07;
public class Test {
public static void main(String[] args) {
//在测试类中调用下面的method方法？
//以前：
//要自己写一个子类继承Animal类
//再创建子类的对象，传递给method方法
// Dog d=new Dog();
// method(d);
//如果Dog类我只用一次，那么还需要单独定义一个类太麻烦了。
method(
new Animal() {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
);
}
public static void method(Animal a){//Animal a=子类对象 多态
a.eat();//编译看左边，运行看右边
}
}
-------------------------------------------------------------枚举
枚举是一种特殊类
枚举类的格式
修饰符 enum 枚举类名{
名称1，名称2;
其他成员;
}
事件
特殊类
1.获取随机数
IDEA快捷操作
