文章目录
- Java SE
- Day1: java学习笔记JDK、JRE与JVM、关键字、八大基本数据类型、引用类型、字符拓展、转义字符、布尔值拓展
- Day2 类型转换、变量、常量、变量的命名规范
- Day3: 类型转换、变量、常量、变量的命名规范、随机数
- Day4 运算符、 自增，自减、 逻辑运算符、位运算、二进制转换十进制、三元运算符、三元运算符、包机制、文档注释
- Day5：Scanner对象、 next（）和nextLine()、顺序结构、选择结构、循环结构 、break和continue关键字
- Day6：Java方法详解、命令行传参、可变参数、递归、作业计算器
- Day7: 数组、Arrays类、冒泡排序及其优化、稀疏数组
- Day8:面向对象（OOP）、方法的定义、方法的调用、实际参数、形式参数、值传递、引用传递 、类与对象的关系、“new“关键字、构造器、面向对象三大特征（继承、封装、多态）super、重写
- Day9: “static“ 关键字、代码块（匿名、静态）、final关键字、抽象类
- Day10: 接口、内部类、异常、异常处理机制、自定义异常
- Day11:数组回顾、集合、 集合的框架体系
- Day12:常用API、
Java SE
Day1: java学习笔记JDK、JRE与JVM、关键字、八大基本数据类型、引用类型、字符拓展、转义字符、布尔值拓展
1.1 JDK、JRE与JVM
1. jdk包含 JRE（Java Runtime Enviroment）：意思是Java的运行环境；它是由JVM和核心类库组成的；如果你不是开发人员，只需要在电脑上安装JRE就可以运行Java程序。
2. jvm(java虚拟机)：JDK最核心的组成部分是JVM（Java Virtual Machine），它是Java虚拟机，真正运行Java程序的地方。
3.JDK、JRE的关系用一句话总结就是：用JDK开发程序，交给JRE运行
4. java既是编译型（C、C++）也是解释型(javascript)语言
1.2 JDK环境变量配置
1.2.1 首先找到此电脑，右键点击属性，可以按照下面的界面；点击【高级系统设置】，再点击【环境变量】
1.2.2 找到JDK的bin目录，复制一下
1.2.3 将JDK的bin目录粘贴在Path环境变量后面
1.2.4.在CMD输入javac -version 看提示信息是否显示你安装JDK的版本号
1.3 JAVA关键字
| abstract | assert | boolean | break | byte |
|---|---|---|---|---|
| case | catch | char | class | const |
| continue | default | do | double | else |
| enum | extends | final | finally | float |
| for | goto | if | implements | import |
| instanceof | int | interface | long | native |
| new | package | private | protected | public |
| return | strictfp | short | static | super |
| switch | synchronized | this | throw | throws |
| transient | try | void | volatile | while |
1.4 标识符注意点
1.5 Java介绍
1、java 基础（Java SE）标准版
2、就业方向：①JavaEE软件工程师②大数据③android开发
3、运行原理示意图
4、Java 开发注意事项和细节说明
5、如何快速掌握技术或知识点
代码示例
//这是java的快速入门，演示java的开发步骤
//对代码的相关说明
//1.public class Hello 表示Hello是一个类，是一个public公有的类
//2.Hello{}表示一个类的开始和结束
//3.public static void main(String[] args)表示一个主方法，即我们程序的入口
//4.main(){}表示方法的开始和结束
//6.;表示语句结束
public class Hello{
//编写一个main方法
public static void main(String[] args){
System.out.println("焦鑫 is studying java");
}
}
//一个源文件中最多只能有一个public类。其他类的个数不限。[演示]
//Dog 是一个类
//编译后，每一个类，都对于一个.class
class Dog{
//一个源文件最多只能有一个public类。其他类的个数不限，也可以将main方法写在非public类中，
//然后指定运行非public类，这样入口方法就是非public的main方法
public static void main(String[] args){
System.out.println("hello,小狗狗");
}
}
class Tiger{
public static void main(String[] args){
System.out.println("hello,小老虎");
}
}
1.5.1 强类型语言
import com.sun.management.VMOption;
import java.math.BigDecimal;
public class Demo02 {
public static void main(String[] args) {
//八大基本数据类型(primitive type) 引用类型（reference type）：类、接口、数组
int num1 = 10;//常用
byte num2 = 20;
short num3 = 30;
long num4 = 30L;//Long类型要在后边加L
//小数：浮点数
float num5 = 50.1F;//float类型要在后边加F
double num6 = 3.1415926;
//字符
char name = '国';
//字符串，String不是关键字，类
String name2 = "李明";
//布尔值：是非
boolean flag = true;
boolean flag2 = false;
//整数扩展、进制、二进制0b、十进制、八进制0、十六进制0x
int i = 10;
int i2 = 010;
int i3 = 0x10;
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("=====================================");
//浮点数拓展 银行业务表示
//BigDecimal 数学工具类
//float 有限 离散 舍入误差 大约 接近但不等于
// double
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
float f = 0.1f; //0.1
double d = 1.0 / 10; //0.1
System.out.println(f == d);//false
float d1 = 13131313131f;
float d2 = d1 + 1;
System.out.println(d1 == d2);//true
System.out.println("=====================================");
//字符拓展
char c1 = 'A';
char c2 = '中';
System.out.println(c1);
System.out.println((int) c1); //强制换行
System.out.println(c2);
System.out.println((int) c2); //强制换行
//所有字符本质还是数字
//编码 Unicode 2字节 0~65536 最早Excel最长65536
// U000 UFFF
char c3 = '\u0061';
System.out.println(c3); //a
//转义字符
// \t 制表符
// \n 换行
System.out.println("hello\tworld");
System.out.println("=====================================");
String sa = new String("hello world");
String sb = new String("hello world");
System.out.println(sa == sb);
String sc = "hello world";
String sd = "hello world";
System.out.println(sc == sd);
//对象 从内容分析
//布尔值拓展
boolean flag3 = true;
if (flag3 == true) { } //新手
if (flag3) { } //老手
//Less is more! 代码要精简易读
}
}
输出：
10
8
16
=====================================
false
true
=====================================
A
65
中
20013
a
hello world
=====================================
false
true
1.6 idea快捷键
Day2 类型转换、变量、常量、变量的命名规范
2.1 数据的表示详解
2.1.1二进制
数据在计算机中都是以二进制表示的
2.2.2 数据的表示
数据的表示形式除了二进制（逢2进1），八进制（逢8进1）、还有十进制（逢10进1）、十六进制（逢10进1）等
2.2.2.1 进制转换
2.2.2.1.1 普通方法
a.二进制是如何表示十进制的2呢？
1
+ 1
--------------------------------
10
这里两个1相加，结果为2，由于二进制满2进1，所以最终结果10
b.那么二进制是如何表示十进制的3呢？
我们已经知道二进制10表示十进制的2，那么二进制10+1就表示十进制的3啊！
10
+ 1
-------
11
十进制的3对应的二进制是11
2.2.2.1.2除2取余法
| 6/2 | 商 | 余数 |
|---|---|---|
| 6/2 | 3 | 0 |
| 3/2 | 1 | 1 |
| 1/2 | 0 | 1 |
然后把余数反转：6对应的二进制是110
2.2.3 字符在计算机中的存储原理
ASCII编码表中字符编码的规律：
1.字符0对应48，后面的1,2,3,4…9 对应的十进制整数依次往后顺延
2.字符a对应97，后面的b,c,d,e…z 对应的十进制整数依次往后顺延
3.字符A对应65，后面的B,C,D,E…Z 对应的十进制整数依次往后顺延
2.2.4 类型转换
2.2.4.1 自动类型转换
```public class Demo03 {
public static void main(String[] args) {
int i = 128;
//byte b = (byte) i; //内存溢出
double b = i;
//强制转换 （类型）变量名 高到低
//自动转换 低到高
System.out.println(i);
System.out.println(b);
/*
注意点
1.不能对布尔值转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量时强制转换
4.转换的时候可能存在内存溢出，或者精度问题
*/
System.out.println("=====================");
System.out.println((int)23.7); //23
System.out.println((int)-45.89f); //-45
System.out.println("=====================");
char c = 'a';
int d = c+1;
System.out.println(d);
System.out.println((char)d);
}
}
输出
128
128.0
=====================
23
-45
=====================
98
b
2.2.4.1 强制类型转换
package com.sesameseed.type;
public class TypeConversionDemo3 {
public static void main(String[] args) {
//目标：强制类型转换
int a =20;
byte b = (byte)a;
System.out.println(b);
int i = 1500;
byte j = (byte)i;
System.out.println(j); //数据溢出
float f1 = 12.5656F;
int i1 = (int)f1;
System.out.println(i1);
}
}
print：
20
-36
12
2.3 变量
注意:
变量的类型只有引用数据类型和基本数据类型（byte,short,char,int,long,float,double,char）两种。
public class Demo06 {
//类变量 static
static double salary = 2500;
//属性：变量
//实例变量：从属于对象；如果不自行初始化，这个类型的默认值 0 0.0
//布尔值：默认false
//除了基本类型，其他的默认值都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量：必须申明和初始化值
int i = 10;
System.out.println(i);
//变量类型 变量名字
Demo06 demo06 = new Demo06();
System.out.println(demo06.age);
System.out.println(demo06.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
System.out.println();
}
}
public class Demo09 {
//修饰符不存在先后顺序
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
2.4 变量的命名规范
Day3: 类型转换、变量、常量、变量的命名规范、随机数
3.1 类型转换
```public class Demo03 {
public static void main(String[] args) {
int i = 128;
//byte b = (byte) i; //内存溢出
double b = i;
//强制转换 （类型）变量名 高到低
//自动转换 低到高
System.out.println(i);
System.out.println(b);
/*
注意点
1.不能对布尔值转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量时强制转换
4.转换的时候可能存在内存溢出，或者精度问题
*/
System.out.println("=====================");
System.out.println((int)23.7); //23
System.out.println((int)-45.89f); //-45
System.out.println("=====================");
char c = 'a';
int d = c+1;
System.out.println(d);
System.out.println((char)d);
}
}
输出
128
128.0
=====================
23
-45
=====================
98
b
3.2 变量和常量
3.2.1 变量案例
public class Demo06 {
//类变量 static
static double salary = 2500;
//属性：变量
//实例变量：从属于对象；如果不自行初始化，这个类型的默认值 0 0.0
//布尔值：默认false
//除了基本类型，其他的默认值都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量：必须申明和初始化值
int i = 10;
System.out.println(i);
//变量类型 变量名字
Demo06 demo06 = new Demo06();
System.out.println(demo06.age);
System.out.println(demo06.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
System.out.println();
}
}
3.2.2 常量案例
- 注意：此案例中PI为我们所定义的常量
public class Demo09 {
//修饰符不存在先后顺序
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
3.3 变量的命名规范
3.4 常用的 dos 命令
-
查看当前目录是有什么内容 dir
dir dir d:\abc2\test200
-
切换到其他盘下：盘符号 cd : change directory
案例演示：切换到 c 盘 cd /D c:
-
切换到当前盘的其他目录下 (使用相对路径和绝对路径演示), …\表示上一级目录
案例演示： cd d:\abc2\test200 cd …\abc2\test200
-
切换到上一级：
案例演示： cd … 5) 切换到根目录：cd \
案例演示：cd \
-
查看指定的目录下所有的子级目录 tree
-
清屏 cls [苍老师]
-
退出 DOS exit
-
说明: 因为小伙伴后面使用 DOS 非常少，所以对下面的几个指令，老韩给大家演示下, 大家了解即可 (md[创建目
录],rd[删除目录],copy[拷贝文件],del[删除文件],echo[输入内容到文件],type,move[剪切]) => Linux,
3.5 随机数
3.5.1 产生一个随机数
package com.sesameseed.random;
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
// 2、创建一个Random对象，用于生成随机数。
Random r1 = new Random();
for (int i = 1;i <= 20;i++) {
int data = r1.nextInt(10);
System.out.println(data);
}
System.out.println("=======0~10的随机数=========");
for (int i = 1;i <= 20;i++) {
// 3、调用Random提供的功能：nextInt得到随机数。
int data2 = r1.nextInt(10) + 1;
System.out.println(data2);
}
System.out.println("=======0~20的随机数=========");
for (int i = 1;i <= 20;i++) {
int data2 = r1.nextInt(10) + 11;
System.out.println(data2);
}
}
}
3.5.2 猜数字小游戏
package com.sesameseed.random;
import java.util.Random;
import java.util.Scanner;
public class RandomTest {
public static void main(String[] args) {
// 1、随机产生一个1-100之间的数据，做为中奖号码。
Random r = new Random();
int lukyNum = r.nextInt(100) + 1;
// 2、定义一个死循环，让用户不断的猜测数据
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("请输入您猜测的数据");
int guessNum = sc.nextInt();
if (guessNum > lukyNum){
System.out.println("猜大了");
} else if (guessNum < lukyNum){
System.out.println("猜小了");
} else {
System.out.println("成功");
break;
}
sc.close(); //凡是属于IO（输入、输出）流的类如果不关闭会一直占用资源
}
}
}
Day4 运算符、 自增，自减、 逻辑运算符、位运算、二进制转换十进制、三元运算符、三元运算符、包机制、文档注释
4.1 运算符
4.1.1 运算优先级
4.2 自增，自减
++i：先做加法运算，再做自加
i++：先做自加，再做加法运算
package operator;
public class Demo04 {
public static void main(String[] args) {
//++ -- 自增，自减 一元运算符
int a= 3;
int b = a++; //执行完这行代码后，先给b赋值，再自增
// a = a+1
System.out.println(a);
// a = a+1;
int c = ++a; //执行完这行代码前，先自增，再给b赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算 2*3 2*2*2 = 8 很多运算用工具类来操作！
double pow = Math.pow(2,3);
System.out.println(pow);
}
}
输出
4
5
3
5
8.0
4.3 逻辑运算符
package operator;
//逻辑运算符
public class Demo05 {
public static void main(String[] args) {
// 与(and) 或（or） 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a && b)); //逻辑与运算：两个变量都为真，结果才为true
System.out.println("a || b:"+(a||b)); //逻辑或运算：两个变量有一个为真，结果才为true
System.out.println("! (a && b):"+!(a&&b)); //如果为真，则变为假，如果是假则变为真
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d);
System.out.println(c);
输出
a && b:false
a || b:true
! (a && b):true
false
5
4.4 位运算
package operator;
//位运算
public class Demo06 {
public static void main(String[] args) {
/*
A = 0011 1100
B = 0000 1101
A&B = 0000 1100(“与”都1为1)
A|B = 0011 1101（“或”有一个1则为1）
A^C =0011 0001（“异或”相同为0，不同为1）
~B = 1111 0010（“取反”完全相反）
2*8 = 16 2*2*2*2
效率极高
<<左移 *2
>>右移 /2，箭头指向那边就叫哪移
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);
}
}
输出
16
4.5 二进制转换十进制
0000 0000 0 二进制默认的0
0000 0001 1 从左到右顺序0~7，则2^0 = 1
0000 0010 2 2^1 = 2
0000 0011 3 2^1 + 2^0 = 3
0000 0100 4 2^2 = 4
0000 1000 8 2^3 = 8
0001 0000 16 2^4 =16
4.6 字符串连接符 +
package operator;
public class Demo07 {
public static void main(String[] args) {
int a = 10;
int b = 20;
a += b; //a = a + b
a -= b; //a = a - b
//字符串连接符 + , String
System.out.println(a + b);
System.out.println("" + a + b); //字符串在前，后边的会拼接
System.out.println(a + b + ""); //字符串在后边，前面会运算
}
}
输出
30
1020
30
4.7 三元运算符
package operator;
//三元运算符
public class Demo08 {
public static void main(String[] args) {
// x ? y : z
//如果x == true,则结果为y，否则为z
int score = 80;
String type = score < 60 ?"不及格":"及格";
// if
System.out.println(type);
}
}
输出
及格
4.8 包机制
4.9 注意在Idea中创建com.baidu 包时不能自动创建子级包的情况
点击左边项目结构右上方的小齿轮，
取消勾选compact middle packlages选项，此时你建立一个com.itheima.package包，
就会显示为com包下itheima包，itheima包下package.java!
4.9.1 import com.jiao.*; //导入这个包下全部的类
4.10 文档注释
package com.jiao.base;
/**
* @author John
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;
/**
* @param name
* @return
* @throws Exception
*/
public String test(String name)throws Exception {
return name;
}
}
4.11 doc命令示例
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
Day5：Scanner对象、 next（）和nextLine()、顺序结构、选择结构、循环结构 、break和continue关键字
5.1 Scanner对象
5.2 next（）和nextLine()
5.2.1 next（）
package com.jiao.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//args是一个字符串数组的变量名，一般习惯性照写
//创建一个扫描对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next发法接收：");
//判断用户有没有输入字符串
if (scanner.hasNext()){
//使用next发法接收
String str = scanner.next(); //程序会等待用户输入完毕
System.out.println("输入的内容为："+str);
}
//凡是属于IO（输入、输出）流的类如果不关闭会一直占用资源
scanner.close();
}
}
输出
使用next发法接收：
hello world
输入的内容为：hello
5.2.2 nextLine()
package com.jiao.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
//从键盘接受数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next发法接收：");
//判断是否还有输入
if(scanner.hasNext()){
String str = scanner.nextLine();
System.out.println("输入的内容为："+str);
}
scanner.close();
}
}
输出
使用next发法接收：
hello world
输入的内容为：hello world
package com.jiao.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
String s = scanner.nextLine();
System.out.println("输出内容为："+s);
scanner.close();
}
}
输出
请输入数据：
欢迎大家 学习 java
输出内容为：欢迎大家 学习 java
5.2.3 练习：我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
package com.jiao.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
//我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
System.out.println("请开始输入:");
//通过循环判断是否还有输入，并在里面对每一次进行求和和统计
while (scanner.hasNextDouble()){
double v = scanner.nextDouble();
m = m + 1; //m++
sum = sum + v;
System.out.println("你输入了第"+m+"个数据,然后当前的结果是sum="+sum);
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m + "个数的平均值为" + (sum / m));
scanner.close();
}
}
输出
请开始输入:
2
你输入了第1个数据,然后当前的结果是sum=2.0
88
你输入了第2个数据,然后当前的结果是sum=90.0
911
你输入了第3个数据,然后当前的结果是sum=1001.0
l
3个数的和为1001.0
3个数的平均值为333.6666666666667
5.3 顺序结构
package com.jiao.struct;
public class ShunXuDemo {
public static void main(String[] args) {
System.out.println("hello1");
System.out.println("hello2");
System.out.println("hello3");
System.out.println("hello4");
}
}
输出
hello1
hello2
hello3
hello4
5.4 选择结构
5.4.1if单选择结构
package com.jiao.struct;
import java.util.Scanner;
public class IfDemo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个内容：");
String s = scanner.nextLine();
//equals:判断字符串是否相等
if (s.equals("Hello")){
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
输出
请输入一个内容：
Hello
Hello
End
5.4.2 if双选择结构
package com.jiao.struct;
import java.util.Scanner;
public class IfDemo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score > 60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
scanner.close();
}
}
输出
请输入成绩：
50
不及格
5.4.3 多单选择结构
package com.jiao.struct;
import java.util.Scanner;
public class IfDemo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score == 100){
System.out.println("满分");
}else if(score < 100 && score >= 90){
System.out.println("A");
}else if(score < 90 && score >= 80){
System.out.println("B");
}else if(score < 80 && score >= 60){
System.out.println("C");
}else if(score < 60 && score >= 0){
System.out.println("不及格");
}else{
System.out.println("输入成绩不合法");
}
scanner.close();
}
}
输出
请输入成绩：
80
B
5.4.4 嵌套if结构
5.4.5 switch多选择结构
package com.jiao.struct;
//case穿透
//switch 匹配一个具体的值
public class SwitchDemo01 {
public static void main(String[] args) {
char grade = 'B';
switch (grade){
case'A':
System.out.println("优秀");
break; //可选,如果没有则会发生case穿透现象，即会输出下边的语句结果
case'B':
System.out.println("良好");
break; //可选,如果没有则会发生case穿透现象，即会输出下边的语句结果
case'C':
System.out.println("及格");
break; //可选,如果没有则会发生case穿透现象，即会输出下边的语句结果
case'D':
System.out.println("再接再厉");
break; //可选,如果没有则会发生case穿透现象，即会输出下边的语句结果
default:
System.out.println("未知等级");
}
}
}
输出
良好
5.4.6 jdk7新特性
package com.jiao.struct;
public class SwitchDemo02 {
public static void main(String[] args) {
String name = "李明";
switch (name){
case "张三":
System.out.println("张三");
break;
case "李明":
System.out.println("李明");
break;
default:
System.out.println("输入不合法");
}
}
}
输出
李明
5.5 循环结构
5.5.1 while循环
package com.jiao.struct;
public class WhileDemo01 {
public static void main(String[] args) {
//输出1~100
int i = 0;
while (i < 100){
i++;
System.out.println(i);
}
}
}
输出
1
2
、、、
100
package com.jiao.struct;
public class WhileDemo02 {
public static void main(String[] args) {
//死循环
while (true){
//等待客户连接
//定时检查
}
}
}
5.5.2 计算1+2+3+…+100 = ?
package com.jiao.struct;
public class WhileDemo03 {
public static void main(String[] args) {
//计算1+2+3+...+100 = ?
int i = 0;
int sum = 0;
while (i <= 100){
sum = sum + i;
i++;
}
System.out.println(sum);
}
}
输出
5050
package com.jiao.struct;
public class DoWhileDemo01 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do{
sum = sum + i;
i++;
}while (i <= 100);
System.out.println(sum);
}
}
输出
5050
package com.jiao.struct;
public class DoWhileDemo02 {
public static void main(String[] args) {
int a = 0;
while (a < 0){
System.out.println(a);
a++;
}
System.out.println("================");
do {
System.out.println(a);
a++;
}while (a < 0);
}
}
输出
0
package com.jiao.struct;
public class ForDemo01 {
public static void main(String[] args) {
int a = 1; //初始化条件
while (a <= 100) { //条件判断
System.out.println(a); //循环体
a += 2; //迭代
}
System.out.println("while循环结束");
//初始化值、条件判断、迭代
for (int i = 1;i <= 100;i++){
System.out.println(i);
}
//100.for 快捷生成 for (int i = 0; i < 100; i++)
System.out.println("for循环结束");
}
}
5.6 练习
5.6.1 练习1：计算0到100间的奇数和偶数的和
package com.jiao.struct;
public class ForDemo02 {
public static void main(String[] args) {
//练习1：计算0到100间的奇数和偶数的和
int oddSum = 0;
int evenSum = 0;
for (int i = 0; i <= 100; i++) {
if (i % 2 != 0){
oddSum += i;
}else {
evenSum += i;
}
}
System.out.println("奇数的和"+oddSum);
System.out.println("偶数的和"+evenSum);
}
}
输出
奇数的和2500
偶数的和2550
5.6.2 练习2：用while或for循环输出1~1000间能被5整除的数，并且每行输出3个
package com.jiao.struct;
public class ForDemo03 {
public static void main(String[] args) {
//练习2：用while或for循环输出1~1000间能被5整除的数，并且每行输出3个
for (int i = 0; i <= 1000; i++) {
if(i % 5 == 0){
System.out.print(i+"\t");
}
if(i % (5*3) == 0){
//System.out.println(); 也可以实现
System.out.println("\n");
}
}
//println 输出完会换行
//print 输出完不会换行
}
}
输出
0
5 10 15
20 25 30
35 40 45
50 55 60
、、、
5.6.3 练习3：输出9X9乘法表
package com.jiao.struct;
public class ForDemo04 {
//练习3：输出9X9乘法表
public static void main(String[] args) {
//1.首先打印第一列
//2.把固定的1再用一个人循环包起来
//3.去掉重复项 i <= j
//4.调整样式
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j + "*" + i + "=" + (j * i) + "\t");
}
System.out.println();
}
}
}
5.7 增强for循环
package com.jiao.struct;
public class ForDemo05 {
public static void main(String[] args) {
int[] numbers = {10,20,30,40,50}; //定义了一个数组
for (int i = 0;i < 5;i++) {
System.out.println(numbers[i]);
}
System.out.println("=============");
//遍历数组元素
for (int x:numbers){ //把number赋值给int
System.out.println(x);
}
}
}
输出
10
20
30
40
50
=============
10
20
30
40
50
5.8 break和continue关键字
break作用：跳出并结束当前所在循环的执行
continue作用：结束本次循环，进入下一次循环
package com.jiao.struct;
public class BreakDemo01 {
public static void main(String[] args) {
int i = 0;
while (i < 100){
i++;
System.out.println(i);
if(i == 30){
break;
}
}
System.out.println("123");
}
}
输出
1
2
3
...
30
123
package com.jiao.struct;
public class ContinueDemo01 {
public static void main(String[] args) {
int i = 0;
while (i < 100){
i++;
if (i % 10 == 0){
System.out.println();
continue;
}
System.out.print(i);
}
}
}
输出
123456789
111213141516171819
212223242526272829
313233343536373839
414243444546474849
515253545556575859
616263646566676869
717273747576777879
818283848586878889
919293949596979899
package com.jiao.struct;
public class Labe1Demo {
public static void main(String[] args) {
//打印101~150之间的所有质数
//质数是指在大于1的自然数中，除了1和它本身以外不再有其他因素的自然数
int count = 0;
//不建议使用
outer:for (int i = 101; i < 150; i++) {
for (int j = 2; j < i/2; j++) {
if (i % j == 0){
continue outer;
}
}
System.out.println(i+"");
}
}
}
输出
101 103 107 109 113 127 131 137 139 149
package com.jiao.struct;
import javax.xml.transform.Source;
public class TextDemo01 {
//打印5行的三角形
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
输出
*
***
*****
*******
*********
Day6：Java方法详解、命令行传参、可变参数、递归、作业计算器
6.1 Java方法详解
package com.jiao.method;
public class Demo01 {
//main方法
public static void main(String[] args) {
//实际参数：实际调用传递给他的参数
int sum = add(1, 2);
System.out.println(sum);
// test();
}
//加法
//形式参数，用来定义作用的
/*
修饰符 返回值类型 方法名（参数类型 参数名）{
...
方法体
...
return 返回值;
}
*/
public static int add(int a, int b) {
return a + b;
}
public static void test() {
for (int i = 0; i <= 1000; i++) {
if (i % 5 == 0) {
System.out.print(i + "\t");
}
if (i % (5 * 3) == 0) {
//System.out.println(); 也可以实现
System.out.println("\n");
}
}
}
}
6.1.1 有返回值的方法，内存分析
package com.sesameseed.method;
public class TestDemo1 {
//TODO 有返回值，可以直接调用
public static void main(String[] args) {
int count1 = paperCount(0.1,8848000);
System.out.println(count1);
}
public static int paperCount(double paperWidth,double mountainHeig){
int count = 0;
while (paperWidth < mountainHeig){
paperWidth *= 2;
count++;
}
return count;
}
}
6.1.2 无返回值的方法，内存分析
package com.sesameseed.method;
public class TestDemo2 {
//TODO 无返回值语法格式，不能调用，在方法中要打印输出
public static void main(String[] args) {
paperCount(0.1,8848000);
}
public static void paperCount(double paperWidth,double mountainHeig){
int count = 0;
while (paperWidth < mountainHeig){
paperWidth *= 2;
count++;
}
System.out.println(count);
}
}
6.2 方法调用
注：Java是值传递
//方法调用
package com.jiao.method;
public class Demo02 {
public static void main(String[] args) {
int max = max(10, 10);
System.out.println(max);
}
//比大小
//方法
public static int max(int num1,int num2){
int result = -1;
if (num1 == num2){
System.out.println("num1 == num2");
return 0; //终止方法
}
if (num1 > num2){
result = num1;
}else {
result = num2;
}
return result;
}
}
6.3 方法重载
6.3.1 方法重载案例一
package com.jiao.method;
public class Demo02 {
public static void main(String[] args) {
int max = max(10, 20);
System.out.println(max);
}
//比大小
public static int max(int num1,int num2){
int result = -1;
if (num1 == num2){
System.out.println("num1 == num2");
return 0; //终止方法
}
if (num1 > num2){
result = num1;
}else {
result = num2;
}
return result;
}
public static double max(double num1,double num2){
double result = -1;
if (num1 == num2){
System.out.println("num1 == num2");
return 0; //终止方法
}
if (num1 > num2){
result = num1;
}else {
result = num2;
}
return result;
}
}
6.3.2 方法重载案例二
package com.sesameseed.parameter;
public class MethodOverDemo1 {
public static void main(String[] args) {
//方法重载
fire();
fire("岛国2");
fire("米国",999);
}
public static void fire(){
fire("岛国");
}
public static void fire(String country){
fire(country,1);
}
public static void fire(String country,int number){
System.out.println("发射了" + number + "枚武器给" + country);
//发射了1枚武器给岛国
//发射了1枚武器给岛国2
//发射了999枚武器给米国
}
}
6.4 命令行传参
package com.jiao.method;
public class Demo03 {
public static void main(String[] args) {
//args.length 数组长度
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "]: " + args[i]);
}
}
}
命令行操作如下：
Microsoft Windows [版本 10.0.22000.493]
(c) Microsoft Corporation。保留所有权利。
D:\IDEA\ideaPreject\javaSE\基础语法\src\com\jiao\method>javac Demo03.java
D:\IDEA\ideaPreject\javaSE\基础语法\src\com\jiao\method>java Demo03
错误: 找不到或无法加载主类 Demo03
D:\IDEA\ideaPreject\javaSE\基础语法\src\com\jiao\method>cd ../
D:\IDEA\ideaPreject\javaSE\基础语法\src\com\jiao>cd ../
D:\IDEA\ideaPreject\javaSE\基础语法\src\com>cd ../
D:\IDEA\ideaPreject\javaSE\基础语法\src>java com.jiao.method.Demo03
D:\IDEA\ideaPreject\javaSE\基础语法\src>java com.jiao.method.Demo03 this is liming
args[0]: this
args[1]: is
args[2]: liming
D:\IDEA\ideaPreject\javaSE\基础语法\src>
**注**：cd ../ 返回上一级
6.5 可变参数
package com.jiao.method;
public class Demo04 {
public static void main(String[] args) {
Demo04 demo04 = new Demo04(); // new一个类
demo04.test(1); // 调用它
}
public void test(int... i){
System.out.println(i[0]);
}
}
6.6 递归
package com.jiao.method;
//递归思想 求阶乘
public class Demo06 {
public static void main(String[] args) {
System.out.println(f(3));
}
public static int f(int n){
if (n == 1){
return 1;
}else{
return n*f(n - 1);
}
}
}
递归思想分析（引出“栈”概念）
注：能不用就别用，会压好多“栈”，会占用过多内存，影响机器性能。
6.7 作业计算器
package com.jiao.method;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
System.out.println("请输入第一个数");
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextDouble()){
double a = scanner.nextDouble();
System.out.println("请输入操作符");
String str = scanner.next();
System.out.println("请输入第二个数");
double b = scanner.nextDouble();
switch (str){
case "+":
add(a,b);
break;
case "-":
minus(a,b);
break;
case "*":
multiply(a,b);
break;
case "/":
except(a,b);
break;
default:
System.out.println("输入运算错误");
break;
}
}
scanner.close();
}
public static void add(double num1,double num2) {
System.out.println(num1 + num2);
}
public static void minus(double num1,double num2) {
System.out.println(num1 - num2);
}
public static void multiply(double num1,double num2) {
System.out.println(num1 * num2);
}
public static void except(double num1,double num2) {
if (num2 == 0){
System.out.println("分母不为0");
}else {
System.out.println(num1 / num2);
}
}
}
6.8 return单独使用
单独使用return语句，可以用来提前结束方法的执行
package com.sesameseed.returndemo;
public class ReturnDemo1 {
public static void main(String[] args) {
//TODO return跳出当前方法
System.out.println("开始");
chu(10,0);
System.out.println("结束");
}
public static void chu(int a, int b){
if (b == 0){
System.out.println("您的数据有误,不执行");
return; // 直接跳出并结束当前chu方法的执行
}
int c = a / b;
System.out.println("除法结果是:" + c);
}
}
//开始
//您的数据有误,不执行
//结束
Day7: 数组、Arrays类、冒泡排序及其优化、稀疏数组
7.1 数组
数组就是一个容器，用来存同种类型的数据的
比如：要存储 “牛二“,“西门“,“全蛋“ 这些数据。
String[] names = {"牛二", "西门", "全蛋"};
package com.jiao.array;
public class ArrayDemo01 {
//变量的类型 变量的名字 = 变量的值
public static void main(String[] args) {
int[] nums; //1.声明一个人数组
nums = new int[10]; //2.创建一个数组
//简便声明数组写法：int[] num2 = new int[10];
//3.给数组元素中赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
//计算所有元素的和
int sum = 0;
//获取数组长度：arras.length
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println("总和为"+sum);
}
}
7.1.1 数组的动态初始化
格式如下:
int[] arr = new int[3]; //数据类型[] 数组名 = new 数据类型[长度];
注意：
使用动态初始化定义数组时，根据元素类型不同，默认值也有所不同。
7.1.2 数组动态初始化案例
package com.sesameseed.array;
public class ArrayDemo4 {
public static void main(String[] args) {
//TODO 动态初始化数组
//1.数据类型[] 数组名 = new 数据类型[长度]
int[] ages = new int[3];
System.out.println(ages[0]);
System.out.println(ages[1]);
System.out.println(ages[2]);
ages[0] = 11;
ages[1] = 22;
ages[0] = 33;
System.out.println(ages[0]);
System.out.println(ages[1]);
System.out.println(ages[2]);
System.out.println("=====其他数据类型元素默认值=====");
char[] ch1 = new char[3]; //char的默认值0
System.out.println((int) ch1[0]);
System.out.println((int) ch1[1]);
System.out.println((int) ch1[2]);
double[] d1 = new double[3]; //double的默认值0
System.out.println((int) d1[0]);
System.out.println((int) d1[1]);
System.out.println((int) d1[2]);
String[] s1 = new String[3]; //String的默认值null
System.out.println(s1[0]);
System.out.println(s1[1]);
System.out.println(s1[2]);
boolean[] b1 = new boolean[3]; //boolean的默认值false
System.out.println(b1[0]);
System.out.println(b1[1]);
System.out.println(b1[2]);
}
}
7.2 内存分析
注意：
基本数据类型储存的是变量，引用数据（如：string）类型储存的是地址（Unicode编码表）
7.3 数组边界
7.4 数组使用
package com.jiao.array;
public class ArrrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
// //JDK1.5, 没有下表
// for (int array : arrays) {
// System.out.println(array);
// }
printArray(arrays);
int[] reverse = reverse(arrays);
printArray(reverse);
}
//反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
//反转的操作
for (int i = 0,j = result.length-1 ; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
//打印数组元素
//修饰符 + 数据类型 + 方法名
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + "");
}
}
}
7.5 多维数组
7.5.1 二维数组
package com.jiao.array;
public class ArrayDemo05 {
public static void main(String[] args) {
//4行2列的数组
/*
{1,2} array[0]
{2,3} array[1]
{3,4} array[2]
{4,5} array[3]
*/
int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
}
// printArray(array[0]); //用printArray方法打印数组
// length长度
// System.out.println(array.length);
// System.out.println(array[0].length);
//用printArray方法打印数组
// public static void printArray(int[] arrays) {
// for (int i = 0; i < arrays.length; i++) {
// System.out.print(arrays[i] + " ");
// }
// }
//}
7.5.2 练习
package com.jiao.array;
public class ArrayDemo05Test {
public static void main(String[] args) {
int [][] array = {{3,6},{5,6},{6,7}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " "); //输出 3 6 5 6 6 7
}
}
// printArray(array[1]); //输出 5 6
// System.out.println(array[2][0]); //输出 6
}
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + " ");
}
}
}
7.5.3 数组求最值
package com.sesameseed.TestDemo;
public class TestDemo1 {
public static void main(String[] args) {
// TODO 定义一个int类型数组，求数组中元素的最大值，并打印最大值
int[] faceScores = {15, 9000, 10000, 20000, 9500, -5};
// 2、定义一个变量用于最终记住最大值
int max1 = faceScores[0];
// 3、从数组的第二个位置开始遍历。
for (int i = 1; i < faceScores.length; i++) {
// i = 1 2 3 4 5
// 判断一下当前遍历的这个数据，是否大于最大值变量max存储的数据，
//如果大于，当前遍历的数据需要赋值给max
if (faceScores[i] >max1){
max1 = faceScores[i];
}
}
System.out.println("最大值" + max1);
}
}
7.5.4 数组求最值
package com.sesameseed.TestDemo;
import java.util.Random;
import java.util.Scanner;
public class TestDemo5 {
public static void main(String[] args) {
//TODO 随机排名
// 1、定义一个动态初始化的数组用于存储5名员工的工号
int[] codes = new int[5];
// 2、提示用户录入5名员工的工号。
Scanner sc = new Scanner(System.in);
for (int i = 0; i < codes.length; i++) {
System.out.println("请你输入当前第" + (i + 1) + "员工编号");
int code = sc.nextInt();
codes[i] = code;
}
// 3、打乱数组中的元素顺序。
// [12, 33, 54, 26, 8]
// i index
Random r = new Random();
for (int i = 0; i < codes.length; i++) {
// codes[i]
// 每遍历到一个数据，都随机一个数组索引范围内的值。
//然后让当前遍历的数据与该索引位置处的值交换。
int index = r.nextInt(codes.length);
// 定义一个临时变量记住index位置处的值
int temp = codes[index];
// 把i位置处的值赋值给index位置处
codes[index] = codes[i];
// 把index位置原来的值赋值给i位置处
codes[i] = temp;
}
// 4、遍历数组中的工号输出即可
for (int i = 0; i < codes.length; i++) {
System.out.print(codes[i] + " ");
}
}
}
7.6 Array类
package com.jiao.array;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,2,3,545,8559,45454,52};
System.out.println(a); //[I@1b6d3586:哈希对象
//打印数组元素
// System.out.println(Arrays.toString(a)); //打印数组元素 toString
// printArray(a);
// Arrays.sort(a); //数组按升序排序 sort
//
// System.out.println(Arrays.toString(a));
Arrays.fill(a,0,1,0); //数组a中第零和第一个下标间的数被0填充，数组填充 fill
System.out.println(Arrays.toString(a));
}
public static void printArray(int[] a) {
for (int i = 0; i < a.length; i++) {
if (i == 0){
System.out.print("{");
}
if (i == a.length - 1){
System.out.print(a[i] + "}");
}else {
System.out.print(a[i] + ", ");
}
}
}
}
7.6.1 冒泡排序
package com.jiao.array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,54,5,8,99,58};
int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
//冒泡排序
//1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2、每一次比较，都会产生出一个最大，或者最小的数字
//3、下一轮这可以少一排序
//4、依次循环直到结束
public static int[] sort(int[] array) {
//临时变量
int temp = 0;
//外层循环，判断我们这个要走多少次
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1] > array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
return array;
}
}
7.6.2 优化
boolean flag = false; //通过flag标识位减少没有意义的比较
package com.jiao.array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,54,5,8,99,58};
int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
//冒泡排序
//1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2、每一次比较，都会产生出一个最大，或者最小的数字
//3、下一轮这可以少一排序
//4、依次循环直到结束
public static int[] sort(int[] array) {
//临时变量
int temp = 0;
boolean flag = false; //通过flag标识位减少没有意义的比较
//外层循环，判断我们这个要走多少次
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1] > array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if (flag == false){
break;
}
}
return array;
}
}
7.6.3 稀疏数组
package com.jiao.array;
public class ArrayDemo08 {
public static void main(String[] args) {
//1、创建一个二维数组 11*11 0:没有棋子 1:黑棋 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始数组
System.out.println("输出原始数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
System.out.println("============");
//转换为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] != 0){
sum++;
}
}
}
System.out.println("有效值的个数："+sum);
//2、创建一个稀疏数组的数组
int[][] array2 = new int[sum + 1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组，将非零的值，存放在稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
count++; //计数 行++
array2[count][0] = i; //第count行，第0列
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0] + "\t"
+array2[i][1] + "\t"
+array2[i][2] + "\t");
}
System.out.println("==============");
System.out.println("还原");
//1、读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//3、给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
System.out.println("还原的数组");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
Day8:面向对象（OOP）、方法的定义、方法的调用、实际参数、形式参数、值传递、引用传递 、类与对象的关系、“new“关键字、构造器、面向对象三大特征（继承、封装、多态）super、重写
8.1 面向过程 & 面向对象
以类的方式组织代码，以对象的组织（封装）数据 ！！！
package com.oop;
//Demo01 类
public class demo01 {
//main 方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名（...）{
//方法体
retur 返回值
}
*/
public String sayHello() {
return "hello world";
}
public void hello() { //返回空值void
return;
}
public int max(int a, int b) {
return a > b ? a : b; //三元运算符
}
}
package com.oop;
import java.io.IOException;
//Demo01 类
public class demo01 {
//main 方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名（...）{
//方法体
retur 返回值
}
*/
//return 结束方法，返回一个结果
public String sayHello() {
return "hello world";
}
public void hello() { //返回空值void
return;
}
public int max(int a, int b) {
return a > b ? a : b; //三元运算符
}
//数组下标越界异常
//抛出异常
public void readFile(String file) throws IOException{
}
}
8.1.1 类的调用
8.1.2 实际参数、形式参数、
package com.oop;
public class Demo03 {
public static void main(String[] args) {
//实际参数和形式参数的类型要对应
int add = Demo03.add(1, 2);
System.out.println(add);
}
public static int add(int a,int b){
return a+b;
}
}
8.1.3 值传递（基本数据类型）
package com.oop;
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
Demo04.change(a);
System.out.println(a); //1
}
//静态方法(static) 返回值为空（void）
public static void change(int a){
a = 10;
}
}
8.1.4 引用传递（数组）
package com.oop;
//引用传递：对象，本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); //null
Demo05.change(person);
System.out.println(person.name); //李明
}
public static void change(Person person){
//perso是一个对象：指向 --> Person person = new Person();
person.name = "李明";
}
}
//定义一个Person类，有一个属性：name
class Person{
String name; //null
}
8.1.5 "new"关键字
package com.oop.demo02;
//学生类
public class Student {
//属性：字段
String name;
int age;
//方法
public void study(){
System.out.println(this.name + "在学习");
}
}
/*
package com.oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象
//studeent对象就是一个Student类的具体实例
Student student = new Student();
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name = "小明";
xiaoming.age = 23;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
xh.name = "小红";
xh.age = 23;
System.out.println(xh.name);
System.out.println(xh.age);
}
}
*/
8.1.6 构造器
下面有一个Student类，构造器名称也必须叫Student；也有空参数构造器，也可以有有参数构造器
package com.oop.demo02;
public class Person {
//一个类即使什么都不写，他也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//1.使用new 关键字，本质是调用构造器
//2.用来初始化值
public Person(){
this.name = "李明";
}
//有参构造:一旦定义了有参构造，无参就必须显示定义 ！！！
public Person(String name){
this.name = name;
}
}
package com.oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person("张三");
System.out.println(person.name);
}
}
构造器
1.和类名相同
2.没有返回值
作用
1.new 本质在调用构造方法
2.初始化对象的值
注意点
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造
生成构造器快捷键 ： ALT + INS
this.name(当前类的值) = name（参数传递进来的值）;
8.1.7 成员变量和局部变量的区别
8.2 小结：
package com.oop;
import com.oop.demo03.Pet;
public class Applicaion {
public static void main(String[] args) {
/*
1.类与对象
类是一个模板：抽象，对象是一个具体的实例
2.方法
定义、调用
3.对应的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈————>堆
4.属性：字段Field 成员变量
默认初始化：
数字： 0 0.0
char:u0000
boolean:false
引用：null
修饰符 属性类型 属性名 = 属性值！
5.对象的创建和使用
-必须使用new 关键字创造对象，构造器 Person lming = new Person();
-对象的属性 liming.name
-对象的方法 lming.sleep
6.类
静态的属性 属性
动态的行为 方法
java的三大特征
封装、继承多态
}
}
8.3 封装（get、set方法）
package com.oop.demo04;
//类 private:私有
public class Student {
//属性私有
private String name; //名字
private int id; //学号
private char sex; //性别
private int age; //年龄
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
//get 获得这个数据
public String getName() {
return this.name;
}
//set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
//ALT + INS 自动生成get 和 set 方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public void setSex(char sex,int age) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 120 || age < 0){
this.age = 3;
}else {
this.age = age;
}
}
}
/*
package com.oop;
import com.oop.demo04.Student;
/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
*/
public class Applicaion {
public static void main(String[] args) {
Student s1 = new Student();
// String name = s1.getName();
s1.setName("李明");
//方法名，参数列表都是观察是否是方法重载
System.out.println(s1.getName());
s1.setAge(999); //不合法的
System.out.println(s1.getAge());
}
}
8.3.1 get、set方法
set：赋值
get：取值
package com.sesameseed.encapsulation;
public class Student {
private double score;
public void setScore(double score){ // 赋值方法
//System.out.println("setScore方法");
if (score >= 0 && score <= 100){
this.score = score;
}else {
System.out.println("输入非法");
}
}
public double getScore(double score){ // 取值方法
return score;
}
public void printPass(){
System.out.println(score > 60 ? "及格" : "不及格");
}
}
8.3.2 实体（JavaBean）类
需要满足下面的要求
实体（JavaBean）类特点：
1、实体（JavaBean）类用来封装数据，只提供对数据进行存和取的方法
2、必须私有成员变量，并为每个变量通提供get、 set方法
案例一：
package com.sesameseed.javabean;
public class Student {
//实体类（JavaBean）特点：用来封装数据，只提供对数据进行存和取的方法
//1.必须私有成员变量，并为每个变量通提供get set方法
private String name;
private double score;
// 3.建议为类提供一个公开的有参数构造器给别人调用，公共的无参构造器，设计示例要求
public Student(String name, double score) {
this.name = name;
this.score = score;
}
//2.必须为类提供一个公开的无参数构造器
public Student() {
}
public String getName() { //调用get方法，需要次方法传输数据
return name;
}
public void setName(String name) { //调用set方法，需要次方法接受数据
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
}
8.3.1 实体类案例一
8.3.2 实体类案例2
Movie对象封装类
package com.sesameseed.oop.oopdemo2;
public class Movie {
//set赋值
//get取值
private int id;
private String name;
private double price;
private double score;
private String director;
private String actor;
private String info;
//公共的无参构造器，设计示例要求
public Movie() {
}
//公共的有参构造器，方便创建对象赋值
public Movie(int id, String name, double price, double score, String director, String actor, String info) {
this.id = id;
this.name = name;
this.price = price;
this.score = score;
this.director = director;
this.actor = actor;
this.info = info;
}
public int getId() { //get取值
return id;
}
public void setId(int id) { //set赋值
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
MovieOperator 操作类
package com.sesameseed.oop.oopdemo2;
public class MovieOperator {
private Movie[] movies; //定义一个电影类型的数组
public MovieOperator(Movie[] movies){
//因为系统中有多部电影，所以电影操作类中，需要有一个Movie的数组
this.movies = movies;
}
// 1、展示系统全部电影信息 movies = [m1, m2, m3, ...]
public void printAllMovies(){
System.out.println("==系统全部信息如下==");
for (int i = 0; i < movies.length; i++) {
Movie m = movies[i];
System.out.println("编号" + m.getId());
System.out.println("名称" + m.getName());
System.out.println("价格" + m.getPrice());
System.out.println("==========");
}
}
// 2、根据电影的编号查询出该电影的详细信息并展示
public void searchMovieById(int id){ //展示信息，不用返回
for (int i = 0; i < movies.length; i++) {
Movie m = movies[i]; //遍历电影中每个对象，用变量m记住
if (m.getId() == id){
System.out.println("已查询到该电影，该电影的信息如下");
System.out.println(m.getId());
System.out.println(m.getName());
System.out.println(m.getScore());
System.out.println(m.getDirector());
System.out.println(m.getActor());
System.out.println(m.getInfo());
return;
}
}
System.out.println("无此电影");
}
// 2、根据电影的名称查询出该电影的详细信息并展示
public void searchMovieByName(String name){
for (int i = 0; i < movies.length; i++) {
Movie m = movies[i]; //遍历电影中每个对象，用变量m记住
// if (m.getName() == name){
if (m.getName().equals(name)){
System.out.println("已查询到该电影，该电影的信息如下");
System.out.println(m.getId());
System.out.println(m.getName());
System.out.println(m.getScore());
System.out.println(m.getDirector());
System.out.println(m.getActor());
System.out.println(m.getInfo());
return;
}
}
System.out.println("无此电影");
}
}
Test测试类
package com.sesameseed.oop.oopdemo2;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Movie[] m = new Movie[4];
//调用公共的有参构造器
Movie m1 = new Movie(1,"水门桥", 38.9, 9.8, "徐克", "吴京","12万人想看");
Movie m2 = new Movie(2, "出拳吧", 39, 7.8, "唐晓白", "田雨","3.5万人想看");
Movie m3 = new Movie(3,"月球陨落", 42, 7.9, "罗兰", "贝瑞","17.9万人想看");
Movie m4 = new Movie(4,"一点就到家", 35, 8.7, "许宏宇", "刘昊然","10.8万人想看");
m[0] = m1;
m[1] = m2;
m[2] = m3;
m[3] = m4;
MovieOperator movieOperator = new MovieOperator(m);
// movieOperator.printAllMovies();
// movieOperator.searchMovieById(5);
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("请输入命令1.展示全部 2.id查询 3.名称查询");
// Scanner scanner = new Scanner(System.in); //放置循环外，减少内存占用
int command = scanner.nextInt();
switch (command){
case 1:
System.out.println("全部信息如下");
movieOperator.printAllMovies();
break;
case 2:
System.out.println("输入影片id信息");
int i = scanner.nextInt();
movieOperator.searchMovieById(i);
break;
case 3:
System.out.println("输入影片名称信息");
String s = scanner.next();
movieOperator.searchMovieByName(s);
break;
default:
System.out.println("无此操作");
}
}
}
}
8.4 继承
package com.oop.demo05;
//在java中，所有的类，都默认或间接继承object
//person 人:父类
public class Person {
// //public
// //protected 默认的
// //default 受保护的
// //private
// private int money = 10_0000_0000;
// public void say(){
// System.out.println("说了一句话");
// }
//
// public int getMoney() {
// return money;
// }
//
// public void setMoney(int money) {
// this.money = money;
// }
}
/*
package com.oop.demo05;
//学生 是（继承） 人 派生类： 子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
public static void main(String[] args) {
// Student student = new Student();
// student.say();
// System.out.println(student.money);
}
}
package com.oop.demo05;
//老师 是（继承） 人 派生类： 子类
public class Teacher extends Person{
}
*/
8.4.1 super注意点：
1.super 调用父类的构造方法，必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super 和this 不能同时调用构造方法
“super” 与 "this"关键字的比较
代表的对象不同
this： 本身调用着这个对象
super： 代表父类对象的应用
前提
this： 没有继承也可以使用
super： 只能在继承条件才可以使用
构造方法
this(); 本类的构造
super(); 父类的构造
8.4.2 重写：
需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大：public > Protected > Default > private（范围大小比较）
4.抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)
注意：重写，子类的方法和父类必要一致，方法体不同！
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足
快捷键： ALT + INS: override 重写
8.4.3 重写和重载的区别
相同点：
- 多态的一种表现形式
不同点：
- 重写：父与子的多态表现
- 重载：一个类中的多态表现
- 重写：返回值、方法名、参数值必须一致，修饰符大于等于父类方法，抛出异常小于等于父类方法抛出的异常
- 重载：方法名相同，参数不同
8.5 多态
什么是多态?
- 多态是在继承、实现情况下的一种现象，表现为: 对象多态、行为多态
对象多态与行为多态：
本引用模块中Teacher和Student都是People的子类
- 对象多态
注意：
- 像这种父类变量接收子类对象的现象是 对象多态 ；
- p1和p2都是People类型，但是p1和p2指向的对象不一样，这种现象称之为对象多态
- 行为多态
注意：
- p1本质上代表学生对象，p2本质上代表老师对象
- p1和p2都可以调用run方法，但是两个run方法表现的行为不同，这种现象就认为是: 行为多态
8.5.1 多态优点
多态形式下，右边的代码是解耦合的，更便于扩展和维护
- 内聚与耦合
内聚是指一个模块内的交互程度，耦合是指模块间的交互程度。我们需要尽力做到高内聚低耦合
多态优点概念引入
解释：刚开始p1指向Student对象，run执行Student对象的业务；假如p1指向Teacher对象 ，run方法执行Teacher对象的业务。
8.5.2 案例一
注意点：
构成多态的规则：
- 1.必须有继承、实现关系
- 2.必须有方法重写
- 3.必须有父类引用指向子类对象
- 4.多态访问变量时，编译看左，运行也看左
- 5.多态访问方法时，编译看左，运行看右
package com.sesameseed.d1_polymorphism;
public class Peolple {
String name = "父类";
public void run(){
System.out.println("人会跑");
}
}
package com.sesameseed.d1_polymorphism;
public class Student extends Peolple{
String name = "学生";
@Override
public void run() {
System.out.println("学生跑的飞快");
}
public void study() {
System.out.println("学生学习");
}
}
package com.sesameseed.d1_polymorphism;
public class Teacher extends Peolple{
String name = "老师";
@Override
public void run() { //重写快捷键，重写的方法名＋enter键
System.out.println("老师跑得慢");
}
public void teach(){
System.out.println("老师教书");
}
}
package com.sesameseed.d1_polymorphism;
public class Test {
//TODO 认识多态
/*
* 构成多态的规则：
* 1.必须有继承、实现关系
* 2.必须有方法重写
* 3.必须有父类引用指向子类对象
* */public static void main(String[] args) {
//多态访问变量时，编译看左，运行也看左
Peolple p1 = new Teacher();
System.out.println(p1.name);
//多态访问方法时，编译看左，运行看右
p1.run();
Peolple p2 = new Student();
System.out.println(p2.name);
p2.run();
}
}
package com.sesameseed.d1_polymorphism.demo1;
public class Test2 {
public static void main(String[] args) {
/* TODO 使用多态的好处，以及多态下的类型转换问题
多态
好处 耦合性低，扩展性强
弊端 不能调用子类独有的方法*/
Teacher t = new Teacher();
go(t);
}
public static void go(Peolple p){ //底层变成多态样子：People p = new Teacher();
System.out.println("==开始==");
p.run();
/* p.teach();
p.study();
//两个方法在多态形式下是不能直接调用
*/
if (p instanceof Student){
Student s = (Student) p;
s.study();
}else if (p instanceof Teacher){
Teacher t = (Teacher) p;
t.teach();
}
// 关于多态转型问题：原本是什么类型，才能还原成什么类型
}
}
8.5.3 “instanceof” 关键字
**instanceof：**判断能不能编译通过（对比理解接口）
package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
public class Applicaion {
public static void main(String[] args) {
//object > String
//object > Person > Teacher
//object > Person > Student
Object object = new Student();
//System.out.println(X instanceof y); //判断能不能编译通过（对比理解接口）
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //false
System.out.println(object instanceof String); //false
System.out.println("===========================================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //false
//System.out.println(person instanceof String); //编译报错
Student student = new Student();
System.out.println("===========================================");
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
//System.out.println(student instanceof Teacher); //编译报错
//System.out.println(student instanceof String); //编译报错
}
}
package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
import com.sun.xml.internal.ws.api.pipe.ServerTubeAssemblerContext;
public class Applicaion {
public static void main(String[] args) {
//类型之间的转换：父类和子类转换 ；基本类型转换 高低64 32 16 8
//低类型转高类型，不需要强制转换
// Person obj = new Student();
//
// //student将这个对象转化为Student类型，我们就可以使用Student类型的方法了
//
// Student student = (Student) obj;
// student.go();
// //以上两句可以合并为 ((Student)obj).go();
Student student = new Student();
//子类转换为父类，可能丢失自己本来的一些方法
student.go();
Person person = student;
}
}
/*
1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型
2.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码 简洁
抽象：封装、继承、多态 抽象类 接口
//object > String
//object > Person > Teacher
//object > Person > Student
Object object = new Student();
//System.out.println(X instanceof y); //判断能不能编译通过（对比理解接口）
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //false
System.out.println(object instanceof String); //false
System.out.println("===========================================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //false
//System.out.println(person instanceof String); //编译报错
Student student = new Student();
System.out.println("===========================================");
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
//System.out.println(student instanceof Teacher); //编译报错
//System.out.println(student instanceof String); //编译报错
}
*/
8.6 面向对象案例
Day9: “static“ 关键字、代码块（匿名、静态）、final关键字、抽象类
9.1 “static” 关键字
9.1.1 static修饰成员变量
Java中的成员变量按照有无static修饰分为两种：类变量、实例变量。
注意：
由于静态变量是属于类的，只需要通过类名就可以调用：类名.静态变量.
实例变量是属于对象的，需要通过对象才能调用：对象.实例变量
9.1.1.1 static修饰成员变量 案例一
package com.sesameseed.p1_staticdemo.demo2;
public class Student {
// 类变量
static String name;
//实例变量（对象的变量）
int age;
}
package com.sesameseed.p1_staticdemo.demo2;
public class Test {
public static void main(String[] args) {
// 目标：掌握有无static修饰成员变量的用法，特点。
// 1、类变量的用法。
// 类名.类变量（推荐）
Student.name = "李明";
System.out.println(Student.name);
// 对象.类变量（不推荐）
Student student = new Student();
student.age = 22;
System.out.println(student.age);
}
}
9.1.1.2 static修饰成员变量 案例二
package com.sesameseed.p1_staticdemo.demo1;
public class User {
//类变量：记录变量的创建次数
public static int number;
//构造器
public User(){
// 如何在自己的类中，获取类变量
//方式一 :this所在的方法被哪个对象调用，this代表哪个对象
// this.number++;
//方式二 类名
User.number++; //推荐！！！
//方式三 就近原则 先在自己所在的位置找，然后再在全局中找
// User.number++;
}
}
package com.sesameseed.p1_staticdemo.demo1;
public class Test {
public static void main(String[] args) {
//创建4个对象
User u1 = new User();
User u2 = new User();
User u3 = new User();
//查看系统创建了多少个User对象
System.out.println(User.number);
}
}
9.1.2 内存原理
注意：
- 1.类变量：属于类，在内存中只有一份，用类名调用
- 2.实例变量：属于对象，每一个对象都有一份，用对象调用
9.1.3 static修饰成员方法
有无static也分为两类：类方法、实例方法
有static修饰的方法，是属于类的，称为类方法；调用时直接用类名调用即可
9.1.3.1 static修饰成员方法案例一
package com.sesameseed.p1_staticdemo.demo3;
public class Student {
double score;
//类方法：
public static void printHelloWorld(){
System.out.println("Hello World!");
System.out.println("Hello World!");
}
public Student() {
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public Student(double score) {
this.score = score;
}
//实例方法（对象的方法）
public void printPass(){
//打印成绩是否合格
System.out.println(score>=60?"成绩合格":"成绩不合格");
}
}
package com.sesameseed.p1_staticdemo.demo3;
public class Test {
public static void main(String[] args) {
//1.调用Student类中的类方法
Student.printHelloWorld();
//2.调用Student类中的实例方法
Student student = new Student();
student.setScore(99.0);
student.printPass();
}
}
9.1.4 内存分析
- 1.类方法：static修饰的方法，可以被类名调用，是因为它是随着类的加载而加载的。
- 2.实例方法：非static修饰的方法，需要创建对象后才能调用，是因为实例方法中可能会访问实例变量，而实例变量需要创建对象后才存在。
9.1.5 static的注意事项
9.2 代码块（匿名、静态）
package com.oop.demo07;
public class Person {
//2：附初始值
{
System.out.println("匿名代码块"); //代码块（匿名代码块）
}
//1 只执行一次
static {
//代码块（静态代码块）
System.out.println("静态代码块");
}
//3
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("====================");
Person person2 = new Person();
}
}
9.3 final关键字
final关键字是最终的意思
- final修饰类：该类称为最终类，特点是不能被继承
- final修饰方法：该方法称之为最终方法，特点是不能被重写。
- final修饰变量：若是
简单数据类型该变量只能被赋值一次**，变量必须被赋值，后期值不能被修改。若是引用数据类型，变量必须被赋值，后期引用类型的地址值不能改，但是引用对象中的属性值可以修改。
9.3.1 案例一
package com.sesameseed.d4_finaldemo;
final class A { }
//class B extends A{}//Cannot inherit from final 'com.sesameseed.d4_finaldemo.A' ,修饰符，类不能被继承了
9.3.2 案例二
package com.sesameseed.d4_finaldemo;
public class C {
public final void test(){}
}
class D extends C{
/* @Override
public void test(){
//test()' cannot override 'test()' in 'com.sesameseed.d4_finaldemo.C'; overridden method is final
//不能重写C类的test方法，因为C类的test方法被final修饰
}*/
}
9.3.3 案例二
package com.sesameseed.d4_finaldemo;
public class FinalDemo1 {
public static void main(String[] args) {
//目标 ：掌握final关键字的基本作用
//变量有几种？ 局部变量，成员变量（类变量，实例变量）
final double a = 3.14;
// a = 3.15;Cannot assign a value to final variable 'a' 不能再给a赋值，因为a是被final修饰的
final int[] arr1 = {10, 20, 30};
// arr1 = null; //Cannot assign a value to final variable 'arr1' 不能给final修饰arr1变量赋值
arr1[1] = 222;
}
}
9.4 抽象类
- 1.认识一下什么是抽象类
在Java中有一个关键字叫abstract，它就是抽象的意思，它可以修饰类也可以修饰方法
- 被abstract修饰的类，就是抽象类
- 被abstract修饰的方法，就是抽象方法（不允许有方法体）
- 2.认识一下什么是抽象类
- 抽象类中可以不写抽象方法，但有抽象方法的
- 类一定是抽象类
- 类有的成员(成员变量、方法、构造器)抽象类都具备。
- 抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
- 一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类
9.4.1 案例一
package com.oop.demo08;
//abstract 抽象类关键字 extends:只能单继承，接口（interface）可以多继承
public abstract class Action {
//约束~有人帮我们实现
//abstract , 抽象方法，只有方法的名字，没有方法的实现
public abstract void doSomething();
/*抽象类特点
1.不能new这个抽象类，只能靠子类去实现它：约束
2.抽象类中可以写普通方法
3.抽象方法必须写在抽象类中
4.抽象的抽象：就是一个约束
*/
//思考题？ new ，里面是否存在构造器？
//存在意义 抽象出来一些要重复的东西，提高开发效率
}
9.4.2 案例二
package com.sesameseed.d2_abstract.demo2;
//abstract修饰类，这个类就是抽象类
public abstract class A {
private String name;
static String schoolName;
//构造方法
public A() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//实例方法
public static String getSchoolName() {
return schoolName;
}
public static void setSchoolName(String schoolName) {
A.schoolName = schoolName;
}
//abstract修饰方法，这个方法就是抽象方法
public abstract void test();
}
package com.sesameseed.d2_abstract.demo2;
public class B extends A{
//TODO 抽象类虽然不能创建对象，但是它可以作为父类让子类继承。而且子类继承父类必须重写父类的所有抽象方法。
//B类继承A类，必须复写test方法
@Override
public void test() {
}
}
package com.sesameseed.d2_abstract.demo2;
//TODO 子类继承父类如果不复写父类的抽象方法，要想不出错，这个子类也必须是抽象类
public abstract class C extends A{
//B类基础A类，此时B类也是抽象类，这个时候就可以不重写A类的抽象方法
}
package com.sesameseed.d2_abstract.demo2;
public class Test {
public static void main(String[] args) {
//抽象类是不能创建对象的，如果抽象类的对象就
// A a = new A();A' is abstract; cannot be instantiated
// a.test();
}
}
9.4.3 案例三
注意：在此案例中，每种动物都有其独特的叫声，因此将父类Animal定义成抽象类，这样的好处就是利用抽象类的子类必须被重写的特点满足各场景使用需求。
package com.sesameseed.d2_abstract.demo1;
public abstract class Animal {
private String name;
//动物叫的行为：不具体，是抽象的
public abstract void cry();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.sesameseed.d2_abstract.demo1;
public class Cat extends Animal{
@Override
public void cry() {
System.out.println(getName() + "喵喵喵");
}
}
package com.sesameseed.d2_abstract.demo1;
public class Dog extends Animal{
public void cry(){
System.out.println(getName() + "汪汪汪");
}
}
package com.sesameseed.d2_abstract.demo1;
public class Pig extends Animal{
@Override
public void cry() {
System.out.println(getName() + "嚯嚯嚯");
}
}
package com.sesameseed.d2_abstract.demo1;
public class Test2 {
public static void main(String[] args) {
/* TODO 掌握抽象类的使用场景和好处
应用场景1.先写父类，让子类继承，拓展性更好
2.先写子类，抽取共性内容到父类，代码更灵活
* 多态三种方式
1.具体类多态（所继承父类方法时普通书写类型）
2.抽象类多态
应用场景选择注意点：
必须 抽象，不是必须 普通
* */
Animal a = new Pig();
a.cry();
}
}
9.5 设计模式——模板方法模式
- 设计模式：是解决某一类问题的最优方案
- 模板方法模式主要解决方法中存在重复代码的问题
9.5.1 案例一
注意：此案例中AB都会有
System.out.println("唱一首你喜欢的歌");此类的重复代码，因此我们将此类重复代码封装在一个方法中，利用模板设计模式减少重复代码。
package com.sesameseed.p3_abstract_template;
//模板方法设计模式
public abstract class C {
//模板方法
public final void sing(){
System.out.println("唱一首你喜欢的歌");
doSing();
System.out.println("唱完了");
}
public abstract void doSing();
}
package com.sesameseed.p3_abstract_template;
public class A extends C{
@Override
public void doSing() {
System.out.println("我们唱p2");
}
}
package com.sesameseed .p3_abstract_template;
public class B extends C{
@Override
public void doSing() {
System.out.println("我们唱P1");
}
}
package com.sesameseed.p3_abstract_template;
public class Test {
public static void main(String[] args) {
//TODO 设计模式解决什么问题，以及怎么写
B b = new B();
b.sing();
}
}
Day10: 接口、内部类、异常、异常处理机制、自定义异常
10.1 接口
- Java提供了一个关键字interface，可以定义出一个特殊的结构: 接口。
public interface 接口名{
// 成员变量(常量)
// 成员方法(抽急方法
}
注意:
- 接口不能创建对象;接口是用来被类实现( implements)的，实现接口的类称为实现类修饰符 class 实现类
- 实现类实现多个接口，必须重写完全部接口的全部推象方法，或者实现类需要定义成抽象类。
implements 接口1,接口2,接口3，..[
一个类可以实现多个接口(接口可以理解成干爹)
10.1.1 案例一
package com.oop.demo09;
//抽象的思维
//interface 定义的关键字，接口都需要有现实类 命名都需要以Impl结尾
public interface UserService {
//常量 public static final
public static final int AGE = 99;
//接口中所有定义其实都是抽象的 public abstract
public abstract void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
对应的现实类
package com.oop.demo09;
//抽象类 extends
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法 (ALT + INS -> Override)
//多继承 利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
接口作用：
1.接口就是一个约束
2.定义一个方法，让不同的人实现
3.方法都是 public static
4.常量都是public static final
5.接口不能实例化，接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法(ALT + INS -> Override)
接口优点：
1.弥补了类单继承的不足，一个类同时可以实现多个接口
2.让程序可以面向接口编程，这样可以灵活切换各种业务实现.
10.1.2 案例二
注意：
- 接口是不能创建对象的
- 接口使用implements类实现，然后就可以再newi一个mplements类对象实现所需方法，
package com.sesameseed.d5_interfacedemo.demo1;
public interface A {
//这里public static final可以加，可以不加。
// public static final String SCHOOL_NAME = "家里蹲";
String SCHOOL_NAME = "家里蹲";
}
package com.sesameseed.d5_interfacedemo.demo1;
public interface B {
void testb1();
void testb2();
}
package com.sesameseed.d5_interfacedemo.demo1;
public interface C {
void testc1();
void testc2();
}
package com.sesameseed.d5_interfacedemo.demo1;
public class D implements B,C{
//实现类D，同时实现B接口和C接口，此时就需要复写四个方法，如下代码
@Override
public void testc1() {
}
@Override
public void testc2() {
}
@Override
public void testb1() {
}
@Override
public void testb2() {
}
}
package com.sesameseed.d5_interfacedemo.demo1;
public class Test {
public static void main(String[] args) {
//打印A接口中的常量
System.out.println(A.SCHOOL_NAME);
接口是不能创建对象的
// A a = new A();'A' is abstract; cannot be instantiated
// D类是接口的实现类，对D类创建对象
D d = new D();
}
}
10.2 内部类
10.2.1 成员内部类
成员内部类就是类中的一个普通成员，类似于成员变量、成员方法。
10.2.1.1 成员内部类案例
package com.sesameseed.d1_inner.peopleinner;
public class Outer {
private int age = 99;
public static String a = "李明";
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static String getA() {
return a;
}
public static void setA(String a) {
Outer.a = a;
}
// 成员内部类
public class Inner{
private String name;
private int age = 88;
// 在内部类中既可以访问自己类的成员，也可以访问外部类的成员
public void test(){
System.out.println(age); //88
System.out.println(a); //李明
int age = 77;
System.out.println(age); //77
System.out.println(this.age); //88
System.out.println(Outer.this.age);//99
}
}
}
package com.sesameseed.d1_inner.peopleinner;
public class Test {
public static void main(String[] args) {
//外部类.内部类 变量名 = new 外部类().new 内部类();
Outer.Inner inner = new Outer().new Inner();
//调用内部类的方法
inner.test();
}
}
10.2.2 静态内部类
成员内部类的前面加了一个static关键字。静态内部类属于外部类自己持有
10.2.2.1 静态内部类案例
package com.sesameseed.d1_inner.staticinner;
public class Outer {
private int age = 90;
public static String schoolName = "家里蹲";
// 静态内部类
public static class Inner{
public void test(){
System.out.println(schoolName);//静态内部类访问外部类的静态变量，是可以的；
// System.out.println(age); //报错 静态内部类访问外部类的实例变量，是不行的
}
}
}
package com.sesameseed.d1_inner.staticinner;
public class Test {
public static void main(String[] args) {
//格式：外部类.内部类 变量名 = new 外部类.内部类();
Outer.Inner inner = new Outer.Inner();
inner.test();
}
}
10.2.3 局部内部类
定义在方法中的类，和局部变量一样，只能在方法中有效。局限性很强，一般在开发中是不会使用的。
10.2.3.1 局部内部类案例
package com.sesameseed.d1_inner.partinner;
public class Outer {
public void test(){
//局部内部类
class Inner{
public void show(){
System.out.println("partInner");
}
}
//局部内部类只能在方法中创建对象，并使用
Inner inner = new Inner();
inner.show();
}
}
package com.sesameseed.d1_inner.partinner;
public class Test {
public static void main(String[] args) {
//new对象调用
Outer outer = new Outer();
outer.test();
}
}
10.2.4 匿名内部类
是一种特殊的局部内部类；所谓匿名，指不需要类声明名字。
new 父类/接口(参数值){
@Override
重写父类/接口的方法;
}
10.2.4.1 匿名内部类案例
package com.sesameseed.d1_inner.anonymousinner;
//继承单继承，实现多实现
/*
实现法比较：
1.普通方法：每一个都要做个类，代码冗余
2.抽象类继承方法：由于继承单继承，只能实现继承一个方法，抽象类虽然必须重写方法，
但是如果想继承实现父类多个方法，又不行了
3.接口实现：接口实现可以多实现，就可以实现父类中多个方法，同时实现类中也必须重写接口类中方法，所以后期可扩展高，适用于动物会游泳，后期他会跑也行，此业务
*/
public interface Swimming {
// public abstract void swim();
void swim(); //public abstract默认有
}
package com.sesameseed.d1_inner.anonymousinner;
public class Test {
public static void main(String[] args) {
//这里后面new 的部分，其实就是一个Swimming的子类对象
//这里隐含的有多态的特性： Swimming swimming = Swimming子类对象;
//第一种书写方法
Swimming swimming = new Swimming(){
@Override
public void swim() {
System.out.println("猫游泳1");
}
};
go(swimming);
//匿名内部类规范写法
go(new Swimming(){
@Override
public void swim() {
System.out.println("猪会游泳2");
}
});
}
public static void go(Swimming swimming){
swimming.swim();
}
}
10.3 异常
10.3.1 简单分类
10.3.2 异常体系结构
10.3.3 Error
10.3.4 Exception
10.4 异常处理机制
package com.exception;
public class Test {
public static void main(String[] args) {
// int a = 1;
// int b = 0;
try {
new Test().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
} finally {
}
//假设要捕获多个异常，从小到大
//try...catch...必须得要！！！ finally 可以不要finally
}
//假设在方法中，处理不了这个异常，方法上抛出异常
public void test(int a,int b) throws ArithmeticException{
if (b == 0){//主队抛出异常 throw throws
throw new ArithmeticException(); //主队抛出异常,一般在方法中使用
}
// System.out.println(a/b);
}
}
/*
try { //try 监控区域
if (b == 0){//主队抛出异常 throw throws
throw new ArithmeticException(); //主队抛出异常
}
System.out.println(a/b);
// new Test().a();
}catch (Error e){ //catch(想要捕获的异常类型) 捕获异常
System.out.println("Error");
}catch (Exception e){
System.out.println("Exception");
}catch (Throwable t){
System.out.println("Throwable");
}finally { //处理善后工作
System.out.println("finaly");
}
*/
package com.exception;
public class Test2 {
public static void main(String[] args) {
int a = 1;
int b = 0;
//CTRL + ALT + T生成自动的捕获异常代码
try {
System.out.println(a / b);
} catch (Exception e) {
System.exit(1); //退出代码
e.printStackTrace(); //打印错误的栈信息
} finally {
}
}
}
10.5 自定义异常
package com.exception.demo02;
//自定义的异常类
public class MyException extends Exception{
//传递数字 > 10 抛出异常
private int detail;
public MyException(int a){
this.detail = a;
}
//toString:异常的打印信息
@Override
public String toString() {
return "MyException{" +
"异常=" + detail +
'}';
}
}
/*
package com.exception.demo02;
public class Test {
//可能会存在异常的方法
static void test(int a) throws MyException {
System.out.println("传递的参数为:" + a);
if (a>10){
throw new MyException(a); //抛出异常
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
test(11);
} catch (MyException e) {
//增加一些处理异常的代码
System.out.println("MyException=>" + e);
}
}
}
输出
传递的参数为:11
MyException=>MyException{异常=11}
*/
10.6 枚举
枚举是一种特殊的类，它的格式是：
public enum 枚举类名{
枚举项1,枚举项2,枚举项3;
}
10.6.1 枚举案例
package com.sesameseed.d2_enumdemo;
public enum Constant {
//Enum:应用场景，用来表示一组信息，进行传参
// public static final int BOY = 0;
// public static final int GIRL = 1;
BOY, GIRL;
}
package com.sesameseed.d2_enumdemo;
public class Test {
public static void main(String[] args) {
//目标： 掌握枚举的使用场景
}
public static void printdeIndo(Constant sex){
switch (sex){
case BOY:
System.out.println("男生");
break;
case GIRL:
System.out.println("男生");
break;
}
}
}
Day11:数组回顾、集合、 集合的框架体系
11.1 数组
11.2 集合
11.3 集合的框架体系
Java 的集合类很多，主要分为两大类，如图 ：[背下来]
11.3.1 Collection_.java
package com.collection.Demo01;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
public class Collection_ {
@SuppressWarnings({"all"}) /*抑制警告错误（就是那种侧边黄色的道道，
可管可不管，非必要）*/
public static void main(String[] args) {
// 1.集合主要是两组（单列集合 双列集合） 单列集合：在集合内放着单个单个的元素
// 2.Collection 接口有两个重要的子接口 list Set,他们实现的子类都是单列集合
// 3.Map 接口的实现子类 是双列集合，存放的 K-V
//单列集合
ArrayList arrayList = new ArrayList();
arrayList.add("liming"); //单列数据
arrayList.add("zhangsan");
//HashMap 双列集合
HashMap hashMap = new HashMap();
hashMap.put("No1","北京"); //双列数据
hashMap.put("No2","上海");
}
}
11.3.2 ArrayList 集合快速入门
package com.sesameseed.arraylist;
import java.util.ArrayList;
public class Demo2 {
public static void main(String[] args) {
//1.创建一个ArrayList的集合对象
ArrayList<String> list = new ArrayList<>();
list.add("第一个");
list.add("第二个");
list.add("第三个");
System.out.println(list); //[第一个, 第二个, 第三个]
// 2、往集合中的某个索引位置处添加一个数据
list.add(1,"mysql");
System.out.println(list); //[第一个, mysql, 第二个, 第三个]
// 3、根据索引获取集合中某个索引位置处的值
String st1 = list.get(1);
System.out.println(st1); //mysql
// 4、获取集合的大小（返回集合中存储的元素个数）
System.out.println(list.size()); //4
// 5、根据索引删除集合中的某个元素值，会返回被删除的元素值给我们
System.out.println(list.remove(1));
System.out.println(list); //[第一个, 第二个, 第三个]
// 6、直接删除某个元素值，删除成功会返回true，反之
System.out.println(list.remove("java")); //false
System.out.println(list); //[第一个, 第二个, 第三个]
// 默认删除的是第一次出现的数据的
list.add("第一个");
System.out.println(list); //[第一个, 第二个, 第三个, 第一个]
System.out.println(list.remove("第一个")); //true 删除成功
System.out.println(list); //[第二个, 第三个, 第一个]
// 7、修改某个索引位置处的数据，修改后会返回原来的值给我们
System.out.println(list.set(1,"修改后的第三个")); //第三个
System.out.println(list); //[第二个, 修改后的第一次, 第一个]
}
}
11.4 Collection 接口和常用方法
package com.collection.Demo01;
import java.util.ArrayList;
import java.util.List;
public class CollectionMethod {
public static void main(String[] args) {
List List = new ArrayList();
//add 添加单个元素
List.add("jack");
List.add(10);
List.add(true);
System.out.println("list=" + List);
//List.remove(0); // 删除第一个元素
//List.remove(true); //list=[jack, 10] 删除某个元素
System.out.println("list=" + List);
//contains查找元素是否存在
System.out.println(List.contains(10)); //查找集合中是否有10这个元素 true contains查找元素是否存在
//size：获取元素个数
System.out.println(List.size()); //2
//isEmpty:判断是否为空
System.out.println(List.isEmpty()); //false
//clear:清空
List.clear();
System.out.println("list=" + List); //list=[]
// addALL:添加多个元素
ArrayList list2 = new ArrayList();
list2.add("红楼梦");
list2.add("三国演义");
List.addAll(list2);
System.out.println("List=" + List); //List=[红楼梦, 三国演义]
// cintainsAll:查找多个人元素是否都存在
System.out.println(List.containsAll(list2)); //true
// removeAll:删除多个元素
List.add("聊斋");
System.out.println("List=" + List); //[红楼梦, 三国演义, 聊斋]
List.removeAll(list2);
System.out.println("LIst=" + List); //[聊斋]
}
}
11.5 Collection 接口遍历元素方式 1-使用 Iterator(迭代器)
a. Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
b.Iterator仅用于遍历集合，其本身并不存放对象
迭代器的，执行原理，如下图1
11.5.1 迭代器代码演示
package com.collection.Demo01;
;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionIterator {
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
// System.out.println("col" + col);
//遍历 col集合
//1.先得到col对应的迭代器
Iterator iterator = col.iterator();
// 2.while循环遍历 itit ==>快速生成while方法 CITL+J显示所有快捷键
System.out.println("第一次遍历");
while (iterator.hasNext()) { //判断是否还有数据
Object obj = iterator.next();
System.out.println("obj+" + obj);
}
//3.当退出while循环后，这时iterator迭代器，指向最后的元素
//iterator.next(); //NoSuchElementException异常
//如果希望再次遍历，需要重置我们的迭代器
System.out.println("第二次遍历");
iterator = col.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj" + obj);
}
}
}
class Book{
private String name;
private String author;
private double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
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 double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
输出
第一次遍历
obj+Book{name='三国演义', author='罗贯中', price=10.1}
obj+Book{name='小李飞刀', author='古龙', price=5.1}
obj+Book{name='红楼梦', author='曹雪芹', price=34.6}
第二次遍历
objBook{name='三国演义', author='罗贯中', price=10.1}
objBook{name='小李飞刀', author='古龙', price=5.1}
objBook{name='红楼梦', author='曹雪芹', price=34.6}
Process finished with exit code 0
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
