数据类型
基本数据类型（8个） 背
数值型
字符型 char
字节型 byte
整型 short短整型 int 整型 long 长整型
浮点型 float单精度浮点型 double 双精度浮点型
逻辑型
布尔类型 boolean
引用数据类型
类（String Date） 接口 Interface 数组 集合 …
整型
| 数据类型 | 大小 | 范围 |
|---|---|---|
| short-----> Short | 2字节 16位 | -32768—32767 |
| int——> Integer | 4字节32位 | -2147483648------2147483647 |
| long ------> Long | 8字节 64位 | -9223372036854775808—9223372036854775807 |
int 的案例
public static void main(String[] args) {
System.out.println(Integer.MIN_VALUE+"------"+Integer.MAX_VALUE);
//int 类型超范围
// 1.计算超出范围
int a = Integer.MAX_VALUE;
int b = a+2;
System.out.println(b);
//2.赋值超出范围 预编译出差
//int c = 2147483648;
}
public static void main(String[] args) {
// System.out.println(Long.MIN_VALUE+"---"+Long.MAX_VALUE);
//long a = 9223372036854775807L*2;
//System.out.println(a);
// 大数运算
/* BigDecimal a1 = new BigDecimal("9223372036854775807");
BigDecimal a2 = new BigDecimal("2");
BigDecimal multiply = a1.multiply(a2);
System.out.println(multiply);*/
long a = 34;
long b = 2147483648l; // 直接写一个数字，默认都是int类型 2147483648超出int的范围 需要将这个数字转换为long
}
字节型
byte ----->Byte 1字节 8位 -128-- 127
字符型
char 2字节16位 符号 字母 数字
''
public static void main(String[] args) {
char c = 'a'; //1.char 数据类型在内存中是以 ASCII码来存放的 ASCII 都是整型
System.out.println((char) (c+1)); // 小范围转大范围 自动转 大范围转小范围 强制转换
}
浮点类型
| 数据类型 | 大小 | 范围 |
|---|---|---|
| float | 4字节32位 | 1.4E-45 — 3.4028235E38 |
| double | 8字节64位 | 4.9E-324—1.7976931348623157E308 |
public static void main(String[] args) {
System.out.println(Double.MIN_VALUE+"---"+Double.MAX_VALUE);
float a = 12.5F;//12.5 默认是double 类型 需要将他强制转换为 float
float b = 11;
double c = 12.5;
}
布尔类型
boolean
就俩个值： true flase
数据类型的默认值
byte (byte)0
short (short) 0
int 0
long 0L
float 0.0f
double 0.0
char 空
boolean false
数据类型的转换
数据类型的转换是有原则有限度的。
转换前后数据要兼容
比如：“你好”------> double
自动类型转换
‘a’+1----->int
总是从小范围转到大范围，
强制类型转换
转换成啥类型 就是啥类型
public static void main(String[] args) {
String a = "12";
int b = Integer.parseInt(a);// String 强转 int
System.out.println(b);
float a1 = 12;
double a2 = 2147483648L;
double a3 = (float)12.1;
float a4 = 2147483648L;
double a5 = 12;
String a6 = "12"+1;
System.out.println(a6);
}
运算符
返回值 = 操作数 运算符 操作数 =======表达式
一元运算符
只有一个操作数的运算符
+ 正号_ 负号! 非 操作数是布尔类型 返回值也是布尔类型
算术运算符
+ 加_ 减* 乘/ 除% 取余
public static void main(String[] args) { /* int a = 10; System.out.println(-a); boolean b = true; System.out.println(!b);*/ // 求一个三位数各个位数上的值，这个数从键盘中输入 //1. 创建一个 Scanner 类型的变量 Scanner in = new Scanner(System.in); //2.从键盘中输入给变量赋值 /* int num = in.nextInt(); // 用in调用函数 nextXXX(); float num12 = in.nextFloat(); byte n = in.nextByte(); //不能给char赋值 String str = in.next(); char ccc = str.charAt(0); //将String double d = in.nextDouble();*/ System.out.println("请输入这个三位数："); int num = in.nextInt(); // 是一个三位数 //个位 int g = num%10; // 123 %10 System.out.println(g); //十位 int s = num/10%10; System.out.println(s); //百位 int b = num / 100; System.out.println(b); }
赋值运算符
==右边赋值给左边
自增自减运算符
++ a++ ++a a = a +1 -- a-- --a a = a-1
public static void main(String[] args) { /*int a =10 ; ++a; System.out.println(a);*/ /* int a = 10; int b = a++; // ++ 在后面，先赋值 后自增 System.out.println(a);// 11 System.out.println(b);// 10*/ /*int a = 10; int b = ++a; // ++ 在前面 先自增 后赋值 System.out.println(a);// 11 System.out.println(b);// 11*/ }
逻辑运算符
操作数和返回值都是布尔类型的运算符
优先级 非 > 与 >或
a || b && ！c
!a ---->dd||b&&cb&&c =ed || e
& 与&& 短路与| 或|| 短路或! 非^ 异或
与
& &&
true & true = truetrue & false =falsefalse & true = falsefalse & false =false
操作数有false 结果就是false。
区别：
& 俩个操作数都要参与运算&& 只要第一个操作数为flase 那么后面的操作数就不参与运算了。
或
| ||
true | true = truetrue | false =truefalse | true = truefalse | false =false
操作数有true 结果就是true
区别：
| 俩个操作数都要参与运算|| 只要第一个操作数为true 那么后面的操作数就不参与运算了。
异或
^
true ^ true = falsetrue ^ false =truefalse ^ true = truefalse ^ false =false
关系运算符
操作数为数值，返回值为布尔类型
>>=<<===!=
位运算符
操作数和返回值都是 二进制数
& 按位与| 按位或 ^ 按位异或~ 按位取反<< 左移位>> 右移位
2&3
0000 00100000 0011----------------0000 0010------------->2
2<<3 0000 0000 0010 0000 0001 0000
public static void main(String[] args) { System.out.println(2<<3); //2^x = 2<<x-1 System.out.println(2<<4); System.out.println(2<<9); //}
字符串连接符
+
条件运算符
三元运算符
x ? y : z;x是一个布尔类型的式子 如果x为 true ，那么结果为y，否则结果为z 注意： y和z的类型应该一致并且返回值和 y 和 z的类型也一致
public static void main(String[] args) { //从键盘中输入一个学生的成绩。如果大于60分，输出“及格”，否则输出 “继续努力” Scanner in = new Scanner(System.in); System.out.println("请输入一个学生的成绩："); int a = in.nextInt(); String s = (a>= 60) ? "及格" : "继续努力"; //String s = (a>= 60) ? 1 : "继续努力"; System.out.println(s); }
表达式
由运算符和操作数组合成的式子，叫做表达式
+12-12a+bA<<2
由算术运算符和赋值运算符组合成新的运算符，由这些新的运算符组合成的表达式，我们称为简洁表达式。
+= a+=b a=a+b-= a-=b*=/=%=
程序的结构
顺序结构选择结构循环结构
顺序结构
自上而下 从左到右 特点：每一条语句都能执行到，并且只执行1次
选择结构
选择性执行特点 ： 并不是每一条语句都能执行到，这取决于条件
if 语句
if(返回值是布尔类型的表达式){ 语句主体；//要么执行到要么执行不到}
public static void main(String[] args) { int a = 0; if (a==21){ // + - * / % // > >= < <= == != System.out.println(a); } }
if……else 语句
非此即彼
if(返回值是布尔类型的表达式){ 语句主体1；}else{ 语句主体2；}当（）当中的结果是true 时执行语句主体1当（）当中的结果是false时，执行语句主题2
int a = 0; if (a!=0){ System.out.println(a); }else { System.out.println("不是0"); }
if……else if……else 语句
if(返回值是布尔类型的表达式){ 语句主体1；}else if（返回值是布尔类型的表达式）{ 语句主体2；}……else{ 语句主体n；}
Scanner input = new Scanner(System.in); System.out.println("请输入一个数字"); int day = input.nextInt(); if (day==1){ System.out.println("星期一"); }else if (day==2){ System.out.println("星期二"); }else if (day==3){ System.out.println("星期三"); }else { System.out.println("输入不合法"); }
switch 语句
switch(是一个值){ //int char String 1+1 case 选择值1: 语句；break； case 选择值2: 语句；break； case 选择值3: 语句；break； …… case 选择值n: 语句；break； default ：语句；}// break的作用，结束switch 语句 // default ：语句；执行完毕 结束 switch 语句
public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.println("请输入一个数字："); int day = in.nextInt(); switch (day){ case 1 : System.out.println("星期1");break; case 2 : System.out.println("星期2");break; case 3 : System.out.println("星期3");break; case 4 : System.out.println("星期4");break; case 5 : System.out.println("星期5");break; case 6 : System.out.println("星期6");break; case 7 : System.out.println("星期7");break; default: System.out.println("输入不合法"); } }
1.从键盘中输入一个数字，判断该数是奇数还是偶数？ public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.println("请输入一个数字："); int num = in.nextInt(); if (num%2==0){ System.out.println("该数是偶数"); }else { System.out.println("该数是奇数"); } }2.设计一个简单的 + - * / 计算器？ public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.println("请输入第一个数："); int a = in.nextInt(); System.out.println("请输入一个运算符："); String str = in.next(); System.out.println("请输入第二个数："); int b = in.nextInt(); switch (str){ case "+" : System.out.println(a+b);break; case "-" : System.out.println(a-b);break; case "*" : System.out.println(a*b);break; case "/" : System.out.println(a/b);break; default: System.out.println("输入的运算符不合法！"); } }
循环结构
多次的执行到某一段语句 多次： 任何次 0 1 2 3
while 语句
while(判断条件){ // 是一个表达式 返回值是一个布尔类型 一般只有关系运算符组成的表达式 循环体； 判断条件改变语句;}
计算10 的累加 ？
public static void main(String[] args) { int x = 1; int num = 0; while (x<=10){ num=num+x; x++; } System.out.println(num); }
do……while 语句
do{ 循环体； 判断条件改变语句;}while(判断条件);// // 是一个表达式 返回值是一个布尔类型 一般只有关系运算符组成的表达式
public static void main(String[] args) { int x = 1; int num = 0; do { num+=x; x++; }while (x<=10); System.out.println(num); }
重点：do while 语句的循环体至少执行一次，while 语句的循环体至少执行0次do while语句的判断条件要比while 语句的判断语句少判断一次
public static void main(String[] args) { int x = 10; while (x>0){ System.out.println(x); x++; } }// 有限次还是无限次
for循环
for(循环变量初值 1；判断语句 2；循环变量变更语句 3){ 循环体 4；}// 循环变量初值 语句只执行一次1 2 4 3 243 243 2假---->结束
public static void main(String[] args) { int num = 1; for (int i = 1;i<=10;i++){ num=num*i; } System.out.println(num); }
循环嵌套语句
for循环的嵌套
外层循环一次，内层循环一遍
public static void main(String[] args) { for (int i = 0; i < 4; i++) { System.out.println("======"+i+"========="); for (int j = 0; j < 3; j++) { System.out.println("《《《《《"+j+"》》》》》"); } } }
输出 99 乘法表？
for (int i = 1; i < 10; i++) { for (int j = 1; j < i+1; j++) { System.out.print(j+"*"+i+"="+(i*j)+"\t"); } System.out.print("\n"); }
循环中断语句
1.break2.continue
break
结束当前的循环，对外层没有影响
public static void main(String[] args) { /*for (int i = 0; i < 10; i++) { if (i==5){ break; } System.out.println(i); }*/ for (int i = 0; i < 4; i++) { System.out.println("======"+i+"========="); for (int j = 0; j < 3; j++) { if (j==1){ break; } System.out.println("《《《《《"+j+"》》》》》"); } } }
continue
结束当前次的循环，对外层没有影响
public static void main(String[] args) { /*for (int i = 0; i < 10; i++) { if (i==5){ continue; } System.out.println(i); }*/ for (int i = 0; i < 4; i++) { System.out.println("======"+i+"========="); for (int j = 0; j < 3; j++) { if (j==1){ continue; } System.out.println("《《《《《"+j+"》》》》》"); } } }
1.编写一个程序，求3个数中的最大值（3个数从键盘输入）2.满足以下条件的所有3位数 如： a^3+b^3+c^3 = abc3.用for循环计算 1！+2！+3！+……+10！4.输出以下图形*********************
数组
具有相同数据类型的一系列数据的集合
存数据取数据数组的应用
声明数组
数据类型 变量名[] ; //C的声明方式//JAVA数据类型[] 变量名 = null； //推荐使用这种数据类型 变量名[] = null；int[] a = nullint a[] = a int数组类型
创建数组
使用 new关键字创建数组
变量名 = new 数据类型[数组的长度]；
int[] a = null； //声明a = new int[10]; //创建int d = 0；d = 13；int d = 13；
a的值等于数组首元素的地址
声明并且创建
数据类型[] 变量名 = new 数据类型[数组的长度]；
int[] a = new int[10]; //声明并且创建
数组的下标
第一个元素从0开始 最后一个元素的下标是 长度-1
下标也叫做索引
存数据
数组的初始化
public static void main(String[] args) { /* int[] a = new int[3]; //声明并且创建 //初始化数据 //1.逐个初始化 a[0] = 30; a[1] = 37; a[2] = 20;*/ // 2.初始化语句 //int[] a = new int[]{30,37,20}; //3.简化初始化语句 推荐的方式 int[] a = {30,37,20}; }
数组的长度
int 数组的长度 = 数组名.length； length 是一个字段（常量）不是方法
int[] a = {30,37,20}; //数组的长度一旦确定就不能发生改变了 System.out.println(a.length); // 常量 String str = "hello"; System.out.println(str.length()); // 方法
取数据
1.使用下标取数据 int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 // 取第6个元素 System.out.println(num[5]); //通过下标来取 num[5] = *(num+5)2.数组的遍历2.1 Arrays类显示数组 缺点：只能显示不能操作 int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 System.out.println(Arrays.toString(num)); //将数组变为字符串输出2.2 for循环 i 0 ---- 数组的长度 （遍历下标，通过下标拿到值） int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 for (int i = 0;i<num.length;i++){ /*if (i==1){ //可操作 num[i] = 100; }*/ System.out.println(num[i]); }2.3 加强 for 循环 直接遍历值 操作性不强 int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 for (int a:num) { // 是一个和数组相同数据类型的变量 ： 你要遍历的数组名 System.out.println(a); }
数组的应用
数组的作用是啥？
存储数据
增 删 改 查
查
1.知道数组的元素值，找该元素的下标。如果找到了输出对应的下标。如果找不到输出-1。
public static void main(String[] args) { int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 Scanner in = new Scanner(System.in); System.out.println("请输入要查找的元素值:"); int value = in.nextInt(); //目标元素 int index = -1; //目标元素的下标 //数组的遍历 for (int i = 0; i < num.length; i++) { if (num[i]==value){ //找到了 index= i; break; } } System.out.println(index); }
2.根据下标找元素
num[下标]
3.排序查（非常重要）
冒泡排序
public static void main(String[] args) { int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 for (int i = 0; i < num.length - 1; i++) { for (int j = 0; j < num.length-1-i; j++) { if (num[j]>num[j+1]){ int temp = num[j]; num[j]=num[j+1]; num[j+1] = temp; } } } System.out.println(Arrays.toString(num)); }
4.二分查找
另外一种知道数组元素找下标的方法
数组一定是有序的
public static void main(String[] args) { int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 Arrays.sort(num); //从小到大排序 System.out.println(Arrays.toString(num)); //二分查找 Scanner in = new Scanner(System.in); System.out.println("请输入要查找的元素值:"); int value = in.nextInt(); //目标元素 int index = -1; //目标元素的下标 int left = 0; int right = num.length-1; while (left<=right){ int mid = (left+right)/2; // 中间值 if (num[mid]==value){ index = mid; break; }else if (num[mid]<value){ left = mid + 1; // }else { right = mid - 1; } } System.out.println(index); }
改
1.知道下标修改 num[下标] = 要改的值；2.知道元素修改 2.1 根据元素找下标 2.2 num[下标] = 要改的值；
增
public static void main(String[] args) { int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 System.out.println(Arrays.toString(num)); int[] newNum = new int[num.length+1]; Scanner in = new Scanner(System.in); System.out.println("请输入要插入的值："); int value = in.nextInt(); System.out.println("请输入要插入的位置："); int index = in.nextInt(); for (int i = 0; i < newNum.length; i++) { if (i<index){ newNum[i]=num[i]; }else if (i==index){ newNum[i]=value; }else { newNum[i] = num[i-1]; } } System.out.println(Arrays.toString(newNum)); }
删
public static void main(String[] args) { int[] num = {12,56,45,23,78,9,10,47,11,2}; //声明 创建 初始化 System.out.println(Arrays.toString(num)); int[] newNum = new int[num.length-1]; Scanner in = new Scanner(System.in); System.out.println("请输入要删除的位置："); int index = in.nextInt(); for (int i = 0; i < newNum.length; i++) { if (i<index){ newNum[i]=num[i]; }else { newNum[i] = num[i+1]; } } System.out.println(Arrays.toString(newNum)); }
二维数组
如果说一维数组是一个数列。那么二维数组就是一个矩阵。
一维数组
1 3 5 6 7 8 3 4 //数列
二维数据
3X4
1 2 3 45 6 7 89 8 7 6 // 矩阵
声明并且创建一个二维数组
数据类型[][] 变量名 = new 数据类型[行数][列数]；int[][] num = new int[3][4];
二维数组初始化
int[][] num = {{1,2,3,4},{5,6,7,8},{9,8,7,6}}；
遍历二维数组
public static void main(String[] args) { int[][] num = {{1,2,3,4},{5,6,7,8},{9,8,7,6}}; for (int i = 0; i < num.length; i++) { //行 for (int j = 0; j < num[i].length; j++) { //列 System.out.print(num[i][j]+"\t"); } System.out.println(); } }
public static void main(String[] args) { char[][] num = {{'*',' ',' ',' '},{'*','*',' ',' '},{'*','*','*',' '}}; for (int i = 0; i < num.length; i++) { //行 for (int j = 0; j < num[i].length; j++) { //列 System.out.print(num[i][j]+"\t"); } System.out.println(); } }
方法
函数
就是一段可以重复执行的代码 模块化的编程思想
*********************Hello*********************
public static void main(String[] args) { for (int i = 0; i < 3; i++) { print(); } System.out.println("Hello"); for (int i = 0; i < 3; i++) { print(); } } // 打印***的方法 public static void print(){ System.out.println("*******"); }
模块化的编程,减少代码冗余
方法定义的格式
public (static) 返回值类型 方法名称(参数列表){ //方法头 方法体； return 值；}
注意
1.方法定义的格式不是固定2.static 表示该方法是一个静态方法。 静态属于类 非静态属于对象3.如果该方法有返回值，1）.返回值类型必须和返回值是相同的类型 2）.那么在方法体中加return 关键字如果该方法没有返回值，1）.返回值类型必须是void 2）.那么在方法体中不需要加return 关键字4.如果该方法有参数，那么在括号中必须将所有的参数都写出来，如果没有参数，那么只保留括号
如何在方法中调用另一个方法
调用静态方法 在其他类中调用 类名.方法名 在本类中调用 直接使用方法名调用非静态方法 创建一个本类类型的变量 初值为 new 类名();
方法的分类
无参数无返回值的方法无参数有返回值的方法有参数无返回值的方法有参数有返回值的方法
如果参数是引用数据类型，那么形参的改变影响实参的值
如果参数是基本数据类型，那么形参的改变不影响实参的值
计算俩个数的和
public class Test { // 计算俩个数的和 条件 int a = 10; int b = 20; 参数 结果 c= a + b; 返回值 public static void main(String[] args) { //add(); /*int sum = add1(); System.out.println(sum);*/ //add2(15,30); //实参 /* int sum = add3(23,9); System.out.println(sum);*/ } //无参数无返回值的方法 特点 ：条件和结果都要自己处理 //计算俩个数的和的方法 public static void add(){ int a = 10; int b = 20; int c = a + b; System.out.println(c); } //无参数有返回值的方法 public static int add1(){ int a = 30; int b = 20; int c = a + b; return c; // 返回到方法调用的地方 在哪调用返回到那个地方 } //有参数无返回值的方法 public static void add2(int a,int b){ //形式参数 形参 int c = a + b; System.out.println(c); } //有参数有返回值的方法 public static int add3(int a,int b){ int c = a + b; return c; }}
方法的重载
用相同的方法名，不同的参数列表去实现不同的功能返回值类型是可以不一致的public void add(int a,int c){ }public int add(int b,double c){ }先看方法名再看参数个数最后看参数类型
方法的递归调用
自己调用自己就叫做递归
public static void main(String[] args) { print(1); } public static void print(int a){ a++; if (a<=10){ System.out.println("**"); print(a); }else { System.exit(1); } }
public static void main(String[] args) { int[] num = {12,56,45,23,78,9,10,47,11,2}; Arrays.sort(num); //从小到大排序 System.out.println(Arrays.toString(num)); int index = erfen(num,0,num.length-1,100); System.out.println(index); } //二分查找 public static int erfen(int[] num,int left,int right,int key){ if (left<=right){ int mid = (left+right)/2; if (num[mid] == key){ return mid; }else if (num[mid] > key){ return erfen(num,left,mid - 1,key); }else { return erfen(num,mid+1,right,key); } }else { return -1; } }
方法返回数组
public static void main(String[] args) { int[] num = {12,56,45,23,78,9,10,47,11,2}; int[] nnm1 = sort1(num); System.out.println(Arrays.toString(nnm1)); } public static int[] sort1(int[] num){ Arrays.sort(num); return num; }
方法传递不定参数
public static void main(String[] args) { add(1); add(1,3); add(1,5,6,2,5,9); } public static void add(int...a){ // a 他是一个数组 int num = 0; for (int i : a) { num +=i; } System.out.println(num); }
作业：
1.冒泡排序2.数组的增加3.数组的删除将以上3个程序用方法实现
面向对象(基础篇)
java 面向对象的三大特性
封装继承多态
类与对象的关系
类： 具有相同的熟悉和行为的同一类事务的总称对象 ：类的具体的某一个体现
类的定义
class 类名{ 成员变量（属性）； 成员方法（行为）；}
package com.edzl.liwang;public class Persion { String name; int age; String sex; public void myself(){ System.out.println("我叫"+name+"我是个"+sex+"娃，今年"+age+"岁了"); }}
对象的创建与使用
public static void main(String[] args) { Persion p1 = new Persion(); p1.name = "李旺"; p1.age = 18; p1.sex = "男"; //以上3条都是给属性赋值 System.out.println(p1.name);//得到属性的值 p1.myself(); Persion p2 = new Persion(); p2.name ="Magic"; p2.age = 37; p2.sex = "男"; p2.myself(); }
使用
使用对象掉调用 属性 （得到属性的值 给属性赋值）使用对象调用 方法
package com.edzl.liwang;/* 封装的步骤* 1.属性私有化* 2.无参有参构造方法* 3.get set 方法* 4.重写toString()** */// 手动封装public class Persion { private String name; private int age; private String sex; public Persion(){//无参数的构造方法 默认隐藏 System.out.println("无参构造"); } public Persion(String name1,int age1,String sex1){ //有参构造不写 是没有的，有参构造写出来，无参数的构造不写就不见了 name = name1; age = age1; sex = sex1; } //给name属性赋值的方法 public void setName(String name1){ name = name1; } //给age属性赋值的方法 public void setAge(int age1){ if (age1>100){ age = 0; }else{ age = age1; } } //给sex属性赋值的方法 public void setSex(String sex1){ sex=sex1; } //得到name属性值的方法 public String getName(){ return name; } //得到age属性值的方法 public int getAge(){ return age; } //得到sex属性值的方法 public String getSex(){ return sex; } @Override public String toString() { //System.out.println("您好，Object"); return "我叫"+name+"我是个"+sex+"娃，今年"+age+"岁了";} /*public void myself(){ System.out.println("我叫"+name+"我是个"+sex+"娃，今年"+age+"岁了"); }*/}
package com.edzl.liwang;public class Test { public static void main(String[] args) { /* Persion p1 = new Persion(); p1.name = "李旺"; p1.age = 18; p1.sex = "男"; //以上3条都是给属性赋值 System.out.println(p1.name);//得到属性的值 p1.myself(); Persion p2 = new Persion(); p2.name ="Magic"; p2.age = 37; p2.sex = "男"; p2.myself(); Persion p3 = p2; // 对象的引用传递 p3.myself();*/ /* Persion p4 = new Persion(); //就会调用无参数的构造方法 p4.setName("宝宝"); p4.setAge(26); p4.setSex("男");*/ /* System.out.println(p4.getName()); System.out.println(p4.getAge()); System.out.println(p4.getSex());*/ //p4.myself(); Persion p5 = new Persion("张三",19,"女"); System.out.println(p5); // 实际上是调用了 Object类的toString() }}
封装性
/* 封装的步骤* 1.属性私有化* 2.无参有参构造方法* 3.get set 方法* 4.重写toString()** */
Alt + insert ---->Override Methods----> object()----提供无参数的构造Alt + insert ---->Const.....--->参数选中点击OK ——————>有参数的构造Alt + insert ---->Getter and Setter --->参数选中点击OK ------>get方法 和set方法Alt + insert ---->toString() ----->点OK ------>生成toString方法
自动封装一个Persion1
package com.edzl.entity;/* 封装的步骤* 1.属性私有化* 2.无参有参构造方法* 3.get set 方法* 4.重写toString()** */public class Persion1 { private String name; private int age; private String sex; public Persion1() { } public Persion1(String name, int age, String sex) { this.name = name; this.age = age; this.sex = sex; //this代表当前对象 区分参数和属性 带this的是属性 } 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 String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } @Override public String toString() { return "Persion1{" + "name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + '}'; }}
package com.edzl.liwang;import com.edzl.entity.Persion1;public class Test { public static void main(String[] args) { Persion1 per2 = new Persion1("张三",19,"女"); System.out.println(per2); per2.setName("张四"); System.out.println(per2.getName()); }}
String类的使用
1.比较俩个字符串是否相等
public static void main(String[] args) { String str1 = "Hello"; String str2 = "Hello"; System.out.println(str1==str2); //true String str3 = new String("Hello"); String str4 = new String("HEllo"); System.out.println(str3==str4);//false System.out.println("---->"+str3.equals(str4)); // equals 比的是String的值 System.out.println(str3.equalsIgnoreCase(str4)); //忽略大小写比值 System.out.println(str1==str3); // ==比较引用数据类型的时候比较的是地址 // equals 比的是String的值 }
2.长度
String str = "he";System.out.println(str.length());
3.截取一个字符
charAt(下标)
4.截取一段
Hello [0--2) He String str = "hello"; String s = str.substring(1); // 从某处开始到结束 String s1 = str.substring(0,2); // 从某处开始到另一处，不包含另一处 System.out.println(s1);
5.得到字符数组
String str = "hello"; char[] chars = new char[5]; str.getChars(0,3,chars,3); System.out.println(chars);
6.转换位字符数组
str.toCharArray(); 参数 返回值
一对一关系
Persion 类 ---------> 李旺
Book类 -----------> 《JAVA学习指南》
李旺 拥有 《JAVA学习指南》 这本书
Persion1类
package com.edzl.entity;/* 封装的步骤* 1.属性私有化* 2.无参有参构造方法* 3.get set 方法* 4.重写toString()** */public class Persion1 { private String name; private int age; private String sex; private Book book; public Persion1() { } public Persion1(String name, int age, String sex, Book book) { this.name = name; this.age = age; this.sex = sex; this.book = book; } 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 String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public Book getBook() { return book; } public void setBook(Book book) { this.book = book; } @Override public String toString() { return "Persion1{" + "name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + ", book=" + book + '}'; }}
Book类
package com.edzl.entity;public class Book { private String name; private String author; private int page; public Book() { } public Book(String name, String author, int page) { this.name = name; this.author = author; this.page = page; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAuthor() { return author; } public void setAuthor(String author) { this.author = author; } public int getPage() { return page; } public void setPage(int page) { this.page = page; } @Override public String toString() { return "Book{" + "name='" + name + '\'' + ", author='" + author + '\'' + ", page=" + page + '}'; }}
public static void main(String[] args) { Book book = new Book("《JAVA学习指南》","宝宝",560); Persion1 persion1 = new Persion1("李旺",18,"男",book); System.out.println(persion1); }
一对多关系 （对象数组）
对象数组就是存放对象的数组，可用于一对多关系
Persion1 类
package com.edzl.entity;import java.util.Arrays;/* 封装的步骤* 1.属性私有化* 2.无参有参构造方法* 3.get set 方法* 4.重写toString()** */public class Persion1 { private String name; private int age; private String sex; private Book[] books; //不止一本书 public Persion1() { } public Persion1(String name, int age, String sex, Book[] books) { this.name = name; this.age = age; this.sex = sex; this.books = books; } 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 String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public Book[] getBooks() { return books; } public void setBooks(Book[] books) { this.books = books; } @Override public String toString() { return "Persion1{" + "name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + ", books=" + Arrays.toString(books) + '}'; }}
Book 类
package com.edzl.entity;public class Book { private String name; private String author; private int page; public Book() { } public Book(String name, String author, int page) { this.name = name; this.author = author; this.page = page; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAuthor() { return author; } public void setAuthor(String author) { this.author = author; } public int getPage() { return page; } public void setPage(int page) { this.page = page; } @Override public String toString() { return "Book{" + "name='" + name + '\'' + ", author='" + author + '\'' + ", page=" + page + '}'; }}
Test
public static void main(String[] args) { Book book1 = new Book("《JAVA学习指南》","宝宝",560); Book book2 = new Book("《C学习指南》","magic",160); Book book3 = new Book("《Python学习指南》","欢老师",160); Book[] books = {book1,book2,book3}; Persion1 persion1 = new Persion1("李旺",18,"男",books); System.out.println(persion1); }
对象数组
public static void main(String[] args) { Book book1 = new Book("《JAVA学习指南》","宝宝",560); Book book2 = new Book("《C学习指南》","magic",160); Book book3 = new Book("《Python学习指南》","欢老师",160); Book[] books = {book1,book2,book3};//在Book[] 类型的数组中，存放了3个 Book 类型的对象 for (int i = 0; i < books.length; i++) { if (i==1){ System.out.println(books[i].getAuthor()); } } //Persion1 persion1 = new Persion1("李旺",18,"男",books); // System.out.println(persion1); }
this
this 代表当前的对象
区分参数和属性 带this的属性
代表当前的无参数构造 this()
static
static ----->静态的 修饰成员 （成员变量 成员方法 内部类 代码块）------->属于类
public class Book { private static String name; private String author; private int page;}
public static void main(String[] args) { Book book1 = new Book("《JAVA学习指南》","宝宝",560); Book book2 = new Book(); Book book3 = new Book(); System.out.println(book3.getName()); System.out.println(book3.getPage()); }
代码块
用{} 包起来的代码就叫代码块
1.普通代码块
直接在方法中或者语句中定义的代码块
作用
1.可以将某一类型的代码放在一起2.缩小变量的作用域
public static void main(String[] args) { { System.out.println("123"); } if (1==1){ { } } }
2.构造块
放在类中的代码块，就是构造块
在构造方法执行之前执行
3.静态代码块
类加载的时候就执行了
package com.edzl.liwang;public class Test1 { private int a; static { System.out.println("静态代码块"); } public Test1(){ System.out.println("无参数的构造"); } { System.out.println("构造块"); } /* public Test1(int a) { System.out.println("有参数的构造"); this.a = a; }*/ public static void main(String[] args) { System.out.println(123); Test1 test1 = new Test1(); }}
内部类
在JAVA中可以将一个类定义在另一个类或者方法当中，这样的类我们称为内部类，分为4类
1.成员内部类2.局部内部类3.匿名内部类4.静态内部类
1.成员内部类
public class Circle { double r = 0; //成员变量 public Circle(double r){ // //成员方法 this.r = r; } class Draw{ // 1.成员内部类 public void draw(){ System.out.println("画了一个半径为"+r+"的圆"); } } public void get(){//成员方法 Draw draw = new Draw(); draw.draw(); } public Draw getDraw(){成员方法 return new Draw(); } public static void main(String[] args) { 成员方法 Circle circle = new Circle(3); //circle.get(); Draw draw = circle.getDraw(); draw.draw(); } }
package com.edzl.liwang;public class Circle { //外部类 double r; //成员变量 public Circle(double r){ // //成员方法 this.r = r; } class Draw{ // 1.成员内部类 public void draw(){ System.out.println("画了一个半径为"+r+"的圆"); } } public static void main(String[] args) { 成员方法 Circle circle = new Circle(12); Draw draw = circle.new Draw();//成员内部类的对象创建必须通过外部类的对象 }}
2.局部内部类
package com.edzl.liwang;public class Circle { //外部类 private double r = 0; public static int content = 1; public Circle() { } public Circle(double r) { this.r = r; } public void get(){ class Draw{ public void draw1(){ System.out.println("画了"+content+"个半径为"+r+"的圆"); } } Draw d = new Draw(); d.draw1(); } public static void main(String[] args) { Circle circle = new Circle(12); circle.get(); }}
3.匿名内部类
先不讲
4.静态内部类
package com.edzl.liwang;public class Circle { //外部类 double r; //成员变量 public Circle(double r){ // //成员方法 this.r = r; } static class Draw{ // 1.成员内部类 public void draw(){ Circle circle = new Circle(12); System.out.println("画了一个半径为"+circle.r+"的圆"); } } public static void main(String[] args) { 成员方法 Draw draw = new Draw(); draw.draw(); }}
单例设计模式
反模式
单 ： 单个
例 ：实例 ------->对象
类名 对象名 = new 类名(); 实例化对象
设计模式： 可以重复利用的解决方案
23种设计模式创建型结构性行为型
单例设计模式三要素
1.在类中需要有静态的私有的本类型变量2.构造方法必须私有的3.提供一个公共的静态的入口点
public class Stu { //1.在类中需要有静态的私有的本类型变量 private static Stu stu = new Stu(); //2.构造方法必须私有的 private Stu(){} //3.提供一个公共的静态的入口点 public static Stu getStu(){ return stu; } public void test(){ System.out.println("测试"); }}
public class TestStu { public static void main(String[] args) { Stu stu1 = Stu.getStu(); Stu stu2 = Stu.getStu(); Stu stu3 = Stu.getStu(); System.out.println(stu1); System.out.println(stu2); System.out.println(stu3); stu1.test(); }}
面向对象高级篇
继承
允许分等级分层次的创建类
继承：子类可以继承父类的属性和行为
动物 -----> Animal ----父类 也叫做 基类 食草动物 ---->CaoAnimal 子类 派生类 -----> 牛 羊 食肉动物 -----> RouAnimal 子类 派生类 ------> 老虎 狮子
为啥要继承？
package com.edzl.jicheng;public class Penguin { //企鹅类 private String name; private int id; public Penguin(String name, int id) { this.name = name; this.id = id; } public void eat(){ System.out.println(name +"正在吃东西"); } public void sleep(){ System.out.println(name +"正在睡觉"); } public void myself(){ System.out.println("大家好，我是"+name+"编号"+id); }}
package com.edzl.jicheng;public class Mouse { // 老鼠 private String name ; private int id; public Mouse(String name, int id) { this.name = name; this.id = id; } public void eat(){ System.out.println(name +"正在吃东西"); } public void sleep(){ System.out.println(name +"正在睡觉"); } public void myself(){ System.out.println("大家好，我是"+name+"编号"+id); }}
以上俩个类代码存在重复，维护性不高。将以上代码共同的部分抽取出来，变成一个父类。
package com.edzl.jicheng;public class Animal { // 动物类 private String name; private int id; public Animal(String name, int id) { this.name = name; this.id = id; } public void eat(){ System.out.println(name +"正在吃东西"); } public void sleep(){ System.out.println(name +"正在睡觉"); } public void myself(){ System.out.println("大家好，我是"+name+"编号"+id); }}
类的继承格式
class父类{}class 子类 extends 父类{ }
public class Mouse extends Animal { // 老鼠 public Mouse(String name, int id) { super(name, id); }}public class Penguin extends Animal { //企鹅类 public Penguin(String name, int id) { super(name, id); //super() 指向父类的构造 }}
继承的分类
单继承 ---- 一个类继承一个类多继承 ---- 一个类继承多个类 java中不支持多重继承 -----爷爷 爸爸 儿子不同类继承同一个类------- 多个类继承一个类
继承的特性
1.子类拥有父类非私有的属性和方法2.子类可以拥有自己的属性和方法3.子类可以通过自己的方式实现父类的方法 重写4.提高了类和类的耦合性，缺点 当事物与事物之间联系的越紧密，耦合性越高 低耦合 A B C
继承的案例
package com.edzl.jicheng;public class Animal { // 动物类 private String name; private int id; int age; public Animal(String name, int id) { this.name = name; this.id = id; } public void eat(){ System.out.println(name +"正在吃东西"); } public void sleep(){ System.out.println(name +"正在睡觉"); } public void myself(){ System.out.println("大家好，我是"+name+"编号"+id); }}
package com.edzl.jicheng;public class Penguin extends Animal { String sex; //企鹅类 public Penguin(String name, int id) { super(name, id); //super() 指向父类的构造 代表父类对象 } public void pai(){ // 子类特有的方法 System.out.println("派肚子"); } @Override //注解 代表方法是重写后的方法 public void eat() { System.out.println("正在吃东西然后喝口水"); }}
public static void main(String[] args) { /*1.子类拥有父类非私有的属性和方法 2.子类可以拥有自己的属性和方法 3.子类可以通过自己的方式实现父类的方法 如果使用子类对象调用该方法，那么调用子类重写后的方法 重写*/ Penguin p = new Penguin("小小",2); p.age = 10; p.pai(); p.eat();// 调用子类重写后的方法 System.out.println(p.age); }
super 和 this
this 指向当前类的对象 分辨参数和属性 this() 指向构造方法，首行super 指向父类的对象 super() 指向父类构造方法 首行
package com.edzl.superTest;public class Animal { public void eat(){ System.out.println("吃---父"); }}class Dog extends Animal{ @Override public void eat() { System.out.println("吃喝----子"); } public void test(){ //特有的方法 this.eat();//-----> Dog dog = new Dog(); dog.eat(); super.eat(); // ----->Animal animal = new Animal(); animal.eat(); }}class Test{ public static void main(String[] args) { Dog dog = new Dog(); dog.eat(); //子类 dog.test(); Animal animal = new Animal(); animal.eat(); }}
final 关键字
final修饰变量 ---->常量 ---->不能被赋值了final 修饰类 ---->代表这个类不能被继承final 修饰方法 --->代表这个方法不能被重写，但是可以被重载
构造器
子类是不继承父类的构造方法的，子类可以调用父类的构造方法，
如果父类的构造方法中带有参数，在子类的构造方法中必须通过super() 调用,并且传以参数，这种方式叫做显式调用。
如果父类的构造方法种没有参数，在子类的构造方法中不需要通过super() 调用,系统会自动调用，这种方式叫做隐式调用。
总结起来一句话： 父类的无参构造是隐式调用，有参构造是显式调用
package com.edzl.superTest;public class SuperClass { private int x; public SuperClass() { System.out.println("superClass的无参数构造"); } public SuperClass(int x) { System.out.println("superClass的有参数构造"); this.x = x; }}class SonClass extends SuperClass{ private int x; public SonClass() { // 自动调用父类的无参构造了 System.out.println("SonClass的无参数构造"); } public SonClass(int x) { /* System.out.println("SonClass的有参数构造"); this.x = x;*/ super(x); }}class Test1{ public static void main(String[] args) { SonClass sonClass = new SonClass(12); }}
重写和重载
多态
多： 多种
态：形态、状态
多种形态
人 类学生 类学生 extends 人学生--->学生的形态 ------>人的形态
package com.edzl.animal;public class Animal { int x = 10; // 动物类 public void cry(){ System.out.println("小动物哭了"); }}
package com.edzl.animal;public class Dog extends Animal { int x = 20; @Override public void cry() { System.out.println("小狗狗哭了"); } public void laugh(){ System.out.println("小狗狗笑了"); }}
package com.edzl.animal;public class Cat extends Animal { int x = 30; @Override public void cry() { System.out.println("小猫哭了"); } public void eat(){ System.out.println("小猫吃一条小鱼"); }}
package com.edzl.animal;public class Test { public static void main(String[] args) { /* Cat cat = new Cat(); //猫的形态 cat.cry(); Dog dog = new Dog(); // 狗的形态 dog.cry();*/ //猫即表现为猫的形态又表现为动物的形态 Animal animalcat = new Cat(); // Cat类型 转换为 Animal 类型 向上转型 animalcat.cry(); // 子类重写后的方法 System.out.println(animalcat.x); Cat cat= (Cat) animalcat; //Animal类型 转换为 Cat 类型 向下转型 前提是必须先有向上转型 cat.eat(); Animal animaldog = new Dog(); Dog类型 转换为 Animal 类型 向上转型 animaldog.cry(); System.out.println(animaldog.x); Dog dog = (Dog)animaldog; dog.laugh(); } // 问： 你是如何理解多态的？ // 一.生活中的多态 /*人 类 学生 类 学生 extends 人 学生--->学生的形态 ------>人的形态*/ // 二. //1.将子类的引用赋值给父类的对象叫做向上转型，通过父类的对象调用方法，调用的是子类重写后的方法 //2.通过父类的对象调用属性，调用的是父类的属性 //3. 通过父类的对象调用子类特有的方法，需要将父类对象强制转换为子类类型}
instanceof关键字 作用：用来判断某个对象是否属于某种数据类型 Animal animaldog = new Dog(); Dog类型 转换为 Animal 类型 向上转型 System.out.println(animaldog instanceof Animal); System.out.println(animaldog instanceof Dog);
案例
1.创建一个父类 Animal
package com.edzl.pet;public class Animal { int age; String name; public void eat(){ System.out.println("我不知道吃啥"); } public void cry(){ System.out.println("我不知道哭啥"); }}
2.创建猫类和狗类，都继承Animal
public class Dog extends Animal { @Override public void cry() { System.out.println("汪汪"); } @Override public void eat() { System.out.println("骨头"); }}public class Cat extends Animal { @Override public void cry() { System.out.println("喵喵"); } @Override public void eat() { System.out.println("小鱼干"); }}
3.创建一个食物类
package com.edzl.pet;public class Food { String name; public void showFood(){ }}
4.创建猫和狗自己喜欢的食物类
package com.edzl.pet;public class Fish extends Food { @Override public void showFood() { System.out.println("食物：鱼"); }}package com.edzl.pet;public class Bone extends Food { @Override public void showFood() { System.out.println("食物：骨头"); }}
5.主人类
package com.edzl.pet;public class Master { // 主人 public void feed(Animal animal,Food food){ animal.eat(); animal.cry(); food.showFood(); }}
6.测试类
public class Test { public static void main(String[] args) { // 喂狗 Master master = new Master(); Dog dog= new Dog(); Bone bone = new Bone(); master.feed(dog,bone); // 喂猫 master.feed(new Cat(),new Fish()); }}
抽象类
如何定义抽象类？
public abstract class Animal{ }
public abstract class Animal { // 抽象类 int a ; public Animal(){} public void eat(){} class N{}}
public static void main(String[] args) { Animal animal = new Animal() ; // 报错 }// 抽象类不能被实例化 但是可以被继承
抽象方法
使用abstract修饰的方法 就叫做抽象方法。
public abstract class Animal { public abstract void eat(); public abstract void sleep();}
package com.edzl.abs;public class Tiger extends Animal { public void eat(){ System.out.println("重写抽象方法"); } @Override public void sleep() { }}
子类继承抽象父类，必须重写父类中所有的抽象方法，如果不重写所有的抽象方法，那么就证明在子类当中还有抽象方法，那么子类就必须是抽象的。
1.格式 public abstract void eat();2.抽象方法只保留方法的方法头，具体的功能由子类重写。3.如果子类也是抽象类，就不需要重写父类的抽象方法
学习目标：
提示：这里可以添加学习目标
例如：一周掌握 Java 入门知识
学习内容：
提示：这里可以添加要学的内容
例如：
1、 搭建 Java 开发环境
2、 掌握 Java 基本语法
3、 掌握条件语句
4、 掌握循环语句
学习时间：
提示：这里可以添加计划学习的时间
例如：
1、 周一至周五晚上 7 点—晚上9点
2、 周六上午 9 点-上午 11 点
3、 周日下午 3 点-下午 6 点
学习产出：
提示：这里统计学习计划的总量
例如：
1、 技术笔记 2 遍
2、CSDN 技术博客 3 篇
3、 学习的 vlog 视频 1 个
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
