[Java知识库]CoreJava笔记

chap01-Java入门

学习方法

• 笔记 课上简单记一下笔记、详细记录问题；课下整理一份属于自己的笔记，推荐手写笔记
• 问题 先独立思考0~5分钟；再问同学、问老师；最后总结问题，确保自己真正会了
• 代码 多写！多写！多写！ 提高手速、熟悉代码

Java

Java发展史

• 1995年 Sun公司发布Java
• 1996年 发布了JDK1.0
• 1999年 发布JDK1.2 逐渐流行 J2EE(企业版) J2SE(标准版) J2ME(移动版)
• 2004年 发布了JDK1.5
• 2005年 改名为JDK5.0 JavaEE JavaSE JavaME
• 2006年 正式开源，走向伟大
• 2009年 Sun公司被Oracle收购
• 2011年 发布了JDK7.0
• 2014年 发布JDK8.0 增加了许多实用的新特性
• 2018年 JavaEE正式由Eclipse基金会（开源组织）负责，JakartaEE(雅加达)

Java的优势（特点）

• 简单性 比C简单
• 跨平台
• 纯面向对象
• 开源、丰富的编程资源

Java的运行机制

• 编译型 c c++ c# uc oc

  • 源文件----编译器—》机器码文件----》运行机器码文件
  • 优点： 效率高 编译一次，运行多次
  • 缺点：不能跨平台

• 解释型 JS 脚本语言

  • 源文件----解释器—》逐行将源文件中的代码解释成机器码，逐行运行
  • 优点：跨平台
  • 缺点：效率低 每次执行都需要重新解释运行

• Java的运行机制： 先编译，后解释

  • 源文件----编译器—》先编译成平台中立的字节码文件（.class文件）—解释器----》逐行解释.class文件，逐行运行
  • 特点： 既可以跨平台，效率又高

环境搭建

• JDK的安装 尽量不要修改安装路径，双击打开，直接下一步

  • JDK的卸载：通过控制面板

• 环境变量的配置

  • JAVA_HOME: JDK的安装路径 C:\Program Files\Java\jdk1.8.0_92
    • 作用：告诉电脑上其他需要使用JDK的软件，JDK的安装位置
  • Path: JDK的bin目录 C:\Program Files\Java\jdk1.8.0_92\bin 推荐使用：%JAVA_HOME%\bin
    • 作用：告诉电脑，JDK自带的命令程序在哪儿
  • CLASSPATH: .
    • 作用： 类路径 .(代表当前路径) JDK5.0后不需要配置

• 名词解释

  • JDK ：Java开发工具包 Java开发程序员必备
    • JDK = JRE + 编译器 + 类库 + 调试工具
  • JRE：Java运行环境 用户使用
    • JRE = 解释器 + JVM
  • JVM：Java虚拟机 所有的Java程序都是运行在JVM中；屏蔽底层操作系统的差异，为Java程序提供跨平台运行

• 开发工具

  • Notepad++ 低级开发工具，前期使用，使用打基础阶段，提高代码熟练度

第一个Java代码

基础语法

1. 创建一个Java源文件（.java文件）

2. class 类 盛放代码的容器、Java程序的基本组成单元

   一个源文件中可以写多个类

3. 类名 区分不同的类

4. {} 划分类的范围

5. public static void main(String[] args){
   		
   }
   主函数，程序运行的入口，只有写在主函数中的代码才可以运行到
   

6. System.out.println();    
   换行打印输出语句：可以将()中的数据输出到控制台或黑窗口中
   System.out.print();  不换行打印输出语句
   

7. 编译命令： javac 源文件名.java

   注意： 当编译成功后，源文件中的每个类都会对应生成一个.class文件

8. 解释命令：java 类名

补充：

打开黑窗口的方式：

1. win键+r键，再出现的窗口中输入cmd
2. 通过notepad++

常用的DOS命令：

命令	作用
盘符名：	切换盘符
cd 文件夹名	进入该文件夹
cd …	退出当前文件夹
cd \	回到盘符
dir	查看当前目录下的所有文件
cls	清屏

公开类

public class 公开类 公共的类，即可以随意访问的类

public 公开的、公共的

使用要求：

1. 公开类类名必须和源文件名一致
2. 每个源文件中最多只能有一个公开类，可以没有

Package

概念： 包 类似于文件夹

作用1： 帮助管理.class文件 （前期）

作用2： 划分项目结构，相同相似作用的源文件放在同一包下 （后期）

语法： package 包名1.包名2.包名3；

注意：
    当使用了package后，原有的编译命令也可以使用，原有的解释命令不能使用
    推荐（强制）使用
        带包编译命令：javac -d . 源文件名.java
        带包解释命令：java 包名.类名

使用要求：

1. package语句，必须写在源文件中有效代码的第一个行
2. 每个源文件中最多只能有一个package语句，可以没有
3. 包名可以写多个，用.连接，代表多层包结构

编码规范

书写规范

• 每行只写一行代码
• 层级之间要有缩进 使用Tab缩进，不要使用空格

标识符命名规范

• 语法：硬性规定，必须遵守
  • 标识符只能由数字、字母、_、$组成，数字不能开头
  • 严格区分大小写
  • 没有长度限制
  • 不能使用关键字、保留字（goto,const）、特殊单词(true、false、null)命名
• 规范：不是硬性规定，可以不遵守，但是强烈建议遵守
  • 望名生义
  • 类名中的所有首字母大写
  • 变量名、函数名首单词首字母小写，其他单词首字母大写
  • 包名全小写
  • 常量名全大写，单词之间使用_连接

注释

概念：描述性的文字

作用：可以对下面的代码做一些解释说明；注释内容不会参与代码的编译过程，自然也不会运行；常常将一些不需要运行但也不想删除的代码注释掉；

• 单行注释

  // 注释内容
  

• 多行注释

  /* 
  	注释内容
  	注释内容
  */
  
  /* 
  class Test{
  	public static void main(String[] args){
  		//System.out.print("Hello");
  		System.out.print("World");
  		
  	}
  } 
  */
  

• 文档注释

  作用：生成一套网页形式的代码说明文档

  特殊编译命令： javadoc -d 文件名 源文件名.java

  注意：只能写在公开类、主函数上面

  语法：

  /**
  这是一个公开类，public 代表公开公共的
  First是公开类类名，必须和源文件名保持一致
  */
  public class First{
  	/**
  	这是一个主函数，是程序运行的入口
  	*/
  	public static void main(String[] args){
  		System.out.println("我的第一个公开类");
  	}
  }
  

chap02-数据类型与运算符

变量

概念： 是内存中的一块儿存储空间，用来存储数据，是存储数据的基本单元

变量的组成： 数据类型 变量名 值（数据）

变量（虚拟的盒子） 实体盒子

数据类型 类型、材质

变量名 名字、标号

值（数据） 具体物品

语法：

1. 声明并赋值    最常用
    数据类型 变量名 = 值；  例如： int a = 10;
2. 先声明，再赋值
    声明：数据类型 变量名； 例如： int a;
    赋值：变量名 = 值； 例如： a = 10;
3. 同时声明多个相同类型的变量并赋值
    数据类型 变量名1 = 值1，变量名2 = 值2，变量名3 = 值3；
    例如：int a = 1,b,c = 3;
	等价于：
        int a = 1;
		int b;
		int c = 3;

注意： Java是强类型语言，变量所存储的值的类型必须与变量的数据类型一致！

数据类型

• 基本数据类型
  • 4类8种
    • 整数类型：byte short int long
    • 浮点数类型: float double
    • 字符类型: char
    • 布尔类型: boolean
• 引用数据类型（对象类型） 无数种！
  • String : 字符串类型

基本数据类型

1. 整数类型

   数据类型	字节长度	取值范围	取值范围（十进制）	举例
   byte	1B	-27~27-1	-128~127	byte b = 10;
   short	2B	-215~215-1	-32768~32767	short s = 10;
   int	4B	-231~231-1	-2147483648~2147483647	int i = 10;
   long	8B	-263~263-1	-9223372036854775808~9223372036854775807	long l = 10L;

   注意：Java中默认的整数类型为int,最常用的也是int

   补充：

   ? 计算机就是一系列的电路开关，每个开关都有两种状态，开或者关，开即1，关即0；

   ? 每个1或者0，都存为一个位（bit,比特），最小的存储单元

   ? 每8个位存储为一个字节（Byte）,字节是最小的存储单位

   ? 通常使用b代表位，B代表字节，即1B=8b;

2. 浮点数类型-小数类型

   数据类型	字节长度	取值范围	举例
   float(单精度浮点数)	4B	-3.4E38~3.4E38	float f = 1.25F;
   double(双精度浮点数)	8B	-1.79E308~1.79E308	double d = 2.5;

   注意： Java中默认的浮点数类型为double,最常用的也是double

3. 字符类型-char

   数据类型	字节长度	取值范围	字符集
   char	2B	0~65535	Unicode（16进制）字符集

   注意：Unicode兼容ASCII字符集

   char类型的三种赋值方式：

   1. 使用’‘引起来的单个字符 char c1 = ‘A’; char c2 = ‘中’;
   2. 整数形式 char c3 = 65;
   3. 使用16进制的Unicode编码 char c4 = ‘\u0041’;

   补充：

   ? 转义字符 \ 在Java中某些具有特殊含义的符号不能之间打印出来，需要使用转义字符

   单个单引号     \'
   单个双引号     \"
   单个\         \\
   水平跳格       \t
   换行          \n
   

4. 布尔类型-boolean

   数据类型	取值	应用场景
   boolean	true(真) false(假)	条件判断

   注意： boolean类型不参与数据运算

引用数据类型

• String 字符串 由一串字符组成的串，必须有“”引起来
  • 字符串拼接： 任何数据类型通过+与字符串拼接到一起，整体都会变成字符串

数据类型转换

除了直接给一个变量赋一个确切的值之外，还可以通过一个变量给另一个变量赋值

int a = 10;

int b = a;

short s = a; // 错误，a 中的值可能会超出s的范围

• 自动类型转换

  当小类型变量赋值为大类型变量时，可以直接赋值

  例如： int a = 10; long l = a;

  转换规则：

  ? byte -> short -> int -> long -> float -> double

  ? char -> int -> long -> float -> double

  class TestDataTypeChange{
  	public static void main(String[] args){
  		// byte b = 10;
  		// short s = b;
  		char c = 'A';
  		int i = c;
  		long l = i;
  		float f = l;
  		double d = f;
  		System.out.println(d);
  	}
  }
  

• 强制类型转换 - 强转 (不常用)

  当大类型变量赋值为小类型变量时，不可以直接赋值，需要强转

  语法： 小数据类型 变量名 = (小数据类型)大数据类型变量名；

  例如： int i = 10000; byte b = (byte) i;

  强转规则：

  1. 大类型整数强转为小类型整数，若不超出范围，数据完整

     例如： long l = 100; int i = l; i = 100;

  2. 大类型整数强转为小类型整数，超出范围，直接舍去高位字节, 数据正负可能发生变化

     例如： int i = 10000； byte b = (byte) i; b = 16

  3. 小数类型转为整数类型，直接舍去小数部分，没有四舍五入

     例如： double d = 12.99; int i = (int)d; i = 12;

     class TestDataTypeChange1{
     	public static void main(String[] args){
     		double d1 = 0.1;
     		double d2 = -0.1;
     		 
     		int i1 = (int)d1;
     		int i2 = (int)d2;
     		System.out.println(i1+"  "+i2); 0  0
     	}
     }
     

自动类型提升

当进行算数运算时

若有double参与，最终结果提升为double类型；

若没有double，有float参与，最终结果提升为float；

若没有double、float，有long参与，最终结果提升为long;

除此之外，统统提升为int类型

class TestDataTypeChange2{
	public static void main(String[] args){
		byte b1 = 1;
		byte b2 = 2;
		int b3 = b1+b2;
		
		System.out.println(b3); 
		
		int i1 = 10;
		// int i2 = 3;
		double i2 = 3;
		System.out.println(i1/i2); 
	}
}

运算符

表达式

概念：通过运算符将变量或值连接起来的式子，并最终会得到一个结果，即表达式

1+2     是
int a = 10; a+10;    是
int a = 10;int b = 20; a+b;  是
int a = 10;int b = 20; a>b;  布尔表达式，结果为true或false

运算符

1. 算数运算符

   + - *（乘，求积）/(除，求商) %（模，求余） 
   
   class TestOperator{
   	public static void main(String[] args){
   		int a = 10;
   		int b = 3;
   		System.out.println(a/b);//3
   		System.out.println(a%b);//1
   	}
   }
   

2. 一元运算符

   运算符	作用
   ++	自增1
   –	自减1

   class TestOperator1{
   	public static void main(String[] args){
   		int a = 5;
   		//a++让a自增1，a++本身也是一个表达式,该表达式的值是a自增之前的值
   		int b = a++;
   		System.out.println(a);//6
   		System.out.println(b);//5
   		
   		//++a让a自增1，++a本身也是一个表达式,该表达式的值是a自增之后的值
   		int c = ++a;
   		System.out.println(a);//7
   		System.out.println(c);//7
   		
   		//-- 同理
   		int n = 5;
   		int m = n--;
   		System.out.println(n);//4
   		System.out.println(m);//5
   		
   		int m1 = --n;
   		System.out.println(n);//3
   		System.out.println(m1);//3
   		
   		int x = 5;
   		int y = (x++)+(++x)+(x--)+(--x);
   		//x      6      7     6     5
   		//y      5      7     7     5
   		System.out.println(x);//5
   		System.out.println(y);//24
   	}
   }
   

3. 赋值运算符

   运算符	作用
   =	将=右边赋值给=左边
   +=	先求和再赋值，不会发生自动类型提升
   -=	先求差再赋值，不会发生自动类型提升
   *=	先求积再赋值，不会发生自动类型提升
   /=	先求商再赋值，不会发生自动类型提升
   %=	先求余再赋值，不会发生自动类型提升

   class TestOperator2{
   	public static void main(String[] args){
   		int a = 5;
   		a += 1;//等价于 a = a+1;
   		System.out.println(a);
   		
   		byte b = 5;
   		//b = (byte)(b+1);
   		b += 1;
   		System.out.println(b);
   	}
   }
   

4. 比较运算符 判断符号两边的值或变量的关系，为布尔表达式，结果为true或false

   运算符	作用
   ==	判断两边的值是否相等
   >	大于
   <	小于
   >=	大于等于
   <=	小于等于
   !=	不等

   class TestOperator3{
   	public static void main(String[] args){
   		int a = 5;
   		int b = 10;
   		System.out.println(a==b);//false
   		System.out.println(a>b);//false
   		System.out.println(a<b);//true
   		System.out.println(a>=5);//true
   		System.out.println(b<=100);//true
   		System.out.println(a!=b);//true
   
   	}
   }
   

5. 逻辑运算符 符号两边均为布尔表达式或布尔值,总结果依然为true或false

   运算符	作用
   &&(与)	若两边布尔表达式均为true，则总结果为true；有一个为false，总结果为false
   ||（或）	若两边布尔表达式均为false，则总结果为false；有一个为true，总结果为true
   !（反）	获取相反的结果，对true取反则为false；对false取反则为true

   class TestOperator4{
   	public static void main(String[] args){
   		int a = 5;
   		int b = 10;
   		System.out.println(a==b||a!=b);//false||true ->true
   		System.out.println(a>b&&a>3);//false&&true -> false
   		System.out.println(a<b&&b==10);//true
   		System.out.println(!(a>=5));// !true -> false
   	}
   }
   

   补充：

   ? && 短路逻辑求与运算符 例如： a>b&&a>c，当a>b为false时，由于整体结果肯定为false，所以并不会判断a>c的结果

   ? || 短路逻辑求或运算符 例如： a>b||a>c，当a>b为true时，由于整体结果肯定为true，所以并不会判断a>c的结果

   ? & 非短路逻辑求与运算符 例如： a>b&a>c， 无论a>b的结果为什么，都会进行a>c的判断

   ? | 非短路逻辑求与运算符 例如： a>b|a>c， 无论a>b的结果为什么，都会进行a>c的判断

   class TestOperator4{
   	public static void main(String[] args){
   		// int n = 10;
   		// int m = 20;
   		// System.out.println(n++>=100&&m++>=0);//false
   		// System.out.println(n);//11
   		// System.out.println(m);//20
   		
   		int n = 10;
   		int m = 20;
   		System.out.println(n++>=100&m++>=0);//false
   		System.out.println(n);//11
   		System.out.println(m);//21
   	}
   }
   

6. 三元运算符

   运算符	作用
   布尔表达式？值1：值2；	对布尔表达式进行判断，若结果为true，则获得值1；若结果为false,则获得值2

   class TestOperator5{
   	public static void main(String[] args){
   		int weekDay = 6;
   		String result = (weekDay>=1&&weekDay<=5?"上课":"休息");
   		System.out.println(result);
   	}
   }
   class TestOperator6{
   	public static void main(String[] args){
   		int n = 9;
   		String result = (n%2==0?"偶数":"奇数");
   		System.out.println(result);
   	}
   }
   

扫描器

Scanner : 扫描器 类库中具有接受数据的功能类

创建语法：

java.util.Scanner sc = new java.util.Scanner(System.in);

常用方法：

sc.next(); 接受字符串

sc.nextInt(); 接收int

sc.nextDouble(); 接收double

sc.nextBoolean(); 接收boolean

import

概念： 导包，将类库中或其他地方的类，导入到当前源文件中

语法： import 包名.类名；

位置： package 语句下面，第一个类上面

注意：

1. *  代表当前包下的所有的类，不包括子包中的类
    例如：import java.util.*；  意味着将util包下的所有类都导入进来
2. *  不能连用
    例如： import java.*.*;  错误！！
3. java.lang是默认导入的！就等价于，在每个源文件中都有一个 import java.lang.*;
4. 当多个包中具有同名的类，需要指定具体路径（在类中写全 包名.类名）
import java.util.*;
import java.sql.*;
class TestImport{
	public static void main(String[] args){
		java.util.Date d = null;
		
	}
}

学习方法

整理笔记—> 抄写案例代码并且加注释 —> 写作业

chap03-流程控制

选择结构

概念： 先对某一条件做判断，根据判断结果，执行相应的流程

如果（我有钱）{
    为所欲为
}
努力挣钱

基本if选择结构

语法：

if(布尔表达式){
    // 逻辑代码
}
//可有可无的后续代码

执行流程：

1. 判断布尔表达式，若结果为true，则执行逻辑代码，并结束整个选择，执行后续代码；
2. 若结果为false，则直接结束整个选择结构，执行后续代码

class TestIf{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		if(n%2==0){
			System.out.println(n+"为偶数");
		}
		System.out.println(n);
	}
}

if else选择结构

语法：

if(布尔表达式){
    //逻辑代码1
}else{
    //逻辑代码2
}
//可有可无的后续代码

执行流程：

1. 先对布尔表达式做判断，若结果为true，则执行逻辑代码1，并结束整个选择结构，执行后续代码；
2. 若结果为false，则执行逻辑代码2，结束整个选择结构，执行后续代码

class TestIfElse{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		if(n%2==0){
			System.out.println(n+"为偶数");
		}else{
			System.out.println(n+"为奇数");
		}
		System.out.println(n);
	}
}
class TestIfElse_a{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		//注意，当if或else后的代码块{}中只有一行代码，可以省略{}
		if(n%2==0)
			System.out.println(n+"为偶数");
		else 
			System.out.println(n+"为奇数");
		
		System.out.println(n);
	}
}

多重if选择结构

语法：

if(布尔表达式1){
    //逻辑代码1
}else if(布尔表达式2){
    //逻辑代码2
}else if(布尔表达式3){
    //逻辑代码3
}else if(布尔表达式4){
    //逻辑代码4
}else{
    //逻辑代码5
}

执行流程：

1. 先对布尔表达式1进行判断，若结果为true，则执行逻辑代码1，并结束整个选择结构，执行后续代码；
2. 若布尔表达式1结果为false，则进行布尔表达式2的判断，若结果为true，则执行逻辑代码2，并结束整个选择结构，执行后续代码；
3. 。。。
4. 若布尔表达式1、2、3、4结果统统为false，则执行else中的逻辑代码5；、

注意： 多个if互相排斥，从上到下，依次判断，当判断成功一个，其他的则不再判断

应用场景：区间判断

class TestIfElseIf{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的预算：");
		int money = sc.nextInt();
		if(money>30000){
			System.out.println("败家之眼、外星人、顶配MacBookPro");
		}else if(money>15000){
			System.out.println("Dell G7");
		}else if(money>8000){
			System.out.println("惠普、华为");
		}else if(money>4000){
			System.out.println("小米、神舟");
		}else{
			System.out.println("步步高点读机");
		}
	}
}
class TestIfElseIf_a{
	public static void main(String[] args){
		int n = 5;
		
		if(n++>10){
			System.out.println("if");
		}else if(n++>5){
			System.out.println("else if1");
		}else if(n++>4){
			System.out.println("else if2");
		}
		System.out.println(n);
	}
}

嵌套if选择结构

语法：

if(外层布尔表达式){
    if(内层布尔表达式1){
        //逻辑代码1
    }
}else{
    if(内层布尔表达式2){
        //逻辑代码2
    }else{
        //逻辑代码3
    }
}
注意： 只要结果完整，可以随意嵌套

执行流程：

1. 先判断外层布尔表达式，若结果为true，则判断内层布尔表达式1，。。。。
2. 若结果为false,则判断内层布尔表达式2，。。。。

class Test27{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入总条数：");
		int n = sc.nextInt();
		System.out.println("请输入每页显示条数：");
		int m = sc.nextInt();
		System.out.println("请输入查询页码：");
		int i = sc.nextInt();
		//计算总页数
		int count = (n%m==0?n/m:(n/m)+1);

		if(i>=1&&i<=count){
			if(i==count){
				System.out.println("显示第"+((i-1)*m+1)+"条到第"+n+"条");
			}else{
				System.out.println("显示第"+((i-1)*m+1)+"条到第"+i*m+"条");
			}		
		}else{
			System.out.println("youwu !");
		}		
	}
}

分支结构

语法：

switch(变量|表达式){
    case 值1:逻辑代码1;break;
    case 值2:逻辑代码1;break;
    case 值3:逻辑代码1;break;
    case 值4:逻辑代码1;break;
    case 值5:逻辑代码1;break;
    default:默认代码;
}

补充： break 关键字，可以结束当前分支或循环结构

变量的类型：byte short int char String(JDK7.0+)

执行流程：

1. 若变量的值为值1，则执行逻辑代码1，然后再通过break关键字结束当前分支结构
2. 若变量的值为值2，则执行逻辑代码2，然后再通过break关键字结束当前分支结构
3. 若变量的值为值3，则执行逻辑代码3，然后再通过break关键字结束当前分支结构
4. …
5. 若变量的值为值n，则执行逻辑代码n，然后再通过break关键字结束当前分支结构
6. 若所有case的值都不匹配，则执行default中的默认代码

注意：

1. 所有能够使用分支结果完成的代码，都可以使用多重if完成
2. case中的值不能重复
3. 若某一个case匹配成功，下面所有的case都不会再进行判断匹配；所以若没有及时的通过break结束分支结构，可能会执行到其他case中的逻辑代码

class TestSwitch{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数：");
		int n = sc.nextInt();
		switch(n){
			case 1:System.out.println("星期一");break;
			case 2:System.out.println("星期二");break;
			case 3:System.out.println("星期三");break;
			case 4:System.out.println("星期四");break;
			case 5:System.out.println("星期五");break;
			case 6:System.out.println("星期六");break;
			case 7:System.out.println("星期日");break;
			default:System.out.println("输入有误！");
		}
	}
}

class TestSwitch{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数：");
		int n = sc.nextInt();
		switch(n){
			case 1:System.out.println("星期一");break;
			case 2:System.out.println("星期二");break;
			case 3:System.out.println("星期三");break;
			case 4:System.out.println("星期四");break;
			case 5:System.out.println("星期五");break;
			case 6://System.out.println("星期天");break;
			case 7:System.out.println("星期天");break;
			default:System.out.println("输入有误！");
		}
	}
}
class TestSwitch{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数：");
		int n = sc.nextInt();
		switch(n){
			default:System.out.println("输入有误！");break;
			case 1:System.out.println("星期一");break;
			case 2:System.out.println("星期二");break;
			case 3:System.out.println("星期三");break;
			case 4:System.out.println("星期四");break;
			case 5:System.out.println("星期五");break;
			case 6://System.out.println("星期天");break;
			case 7:System.out.println("星期天");break;
			
		}
	}
}
class TestSwitch1{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个名字：");
		String name = sc.next();
		switch(name){
			case "孙悟空":System.out.println("齐天大圣");break;
			case "猪罡鬣":System.out.println("天蓬元帅");break;
			case "沙和尚":System.out.println("卷帘大将");break;
			case "乔碧罗":System.out.println("幻影坦克");break;
			default:System.out.println("路人甲");
		}
	}
}

局部变量

概念：定义在函数（方法）内部的变量

使用要求：

1. 先赋值，再使用
2. 作用范围：从定义的那一行开始，到定义所在的代码块的结束
3. 作用范围重合内，变量名不能重复

class Test{
	public static void main(String[] args){
		int a = 10;
		if(a>0){
			//int a = 1;报错，命名重复
			int b = 20;
		}
		System.out.println(a+" "+b);//报错，找不到b变量
	}
}

循环结构

概念：满足某个条件，即可重复执行的一段代码

核心思路图：

while循环

语法：

while(布尔表达式){
    // 循环体（逻辑代码）
}
//可有可无的后续代码

执行流程：

1. 判断布尔表达式(循环条件),若结果为true，则执行循环体
2. 当循环体执行结束后，再次进行布尔表达式的判断，若结果为true，依然执行循环体
3. 直至布尔表达式结果为false时，结束循环，执行后续代码

循环的组成部分： 循环变量、循环条件、循环体、循环迭代语句

while循环的特点： 先判断，再执行；不确定性循环，适用于循环次数不明确的场景

class TestWhile{
	public static void main(String[] args){
		//需求：打印十次HelloWorld
		//1. 循环变量：控制循环次数
		int i = 1;
		//由于没有真正的参与到循环的过程中，不属于循环变量
		int j = 1;
		//2. i<=10  循环条件：决定是否进行循环
		while(i<=10){
			//3. 循环体：每次循环需要执行的业务代码
			System.out.println("Hello World "+i);
			//4. 循环迭代（条件更新语句）：控制循环变量的改变
			i++;
			j++;
		}
	}
}

死循环：

死循环原因：缺少循环迭代语句
class TestWhile1{
	public static void main(String[] args){
		//需求：打印十次HelloWorld
		//1. 循环变量：控制循环次数
		int i = 1;
		//2. i<=10  循环条件：决定是否进行循环
		while(i<=10){
			//3. 循环体：每次循环需要执行的业务代码
			System.out.println("Hello World "+i);
			//4. 循环迭代（条件更新语句）：控制循环变量的改变
		}
	}
}
死循环原因：循环条件永远为true
class TestWhile2{
	public static void main(String[] args){
		//需求：打印十次HelloWorld
		//1. 循环变量：控制循环次数
		int i = 1;
		//2. i<=10  循环条件：决定是否进行循环
		while(true){
			//3. 循环体：每次循环需要执行的业务代码
			System.out.println("Hello World "+i);
			//4. 循环迭代（条件更新语句）：控制循环变量的改变
			i++;
		}
	}
}

随堂小练习：
1. 通过循环，计算1~100的和
    提示：需要定义额外变量，接受1~100之间的每个数
class TestWhile3{
	public static void main(String[] args){
		//1+2+3+4+...+100
		// i为循环变量，还充当了1~100之间的每个数
		int i = 1;
		// 可以将1~100之间的每个数都加到sum上，最后sum的值就是最终结果
		int sum = 0;
		//通过循环可以获取到1~100之间的每个数，并用i表示
		while(i<=100){
			//将每次循环的i都加到sum中
			sum += i;
			//sum = sum+i;
			//循环迭代语句，使i的值发生改变
			i++;
		}
		System.out.println(sum);
		/* 
		i=1<=100
			sum = sum+i = 0+1; i++ -> i=2 
		i=2<=100
			sum = sum+i = 0+1+2; i++ -> i=3 
		i=3<=100
			sum = sum+i = 0+1+2+3; i++ -> i=4 
		....
		i=100<=100
			sum = sum+i = 0+1+2+3+..+99+100; i++ -> i=101 
		i=101>100	
			循环结束 
		*/
	}
}
2. 通过循环，计算1~100的偶数和
class TestWhile4{
	public static void main(String[] args){
		//1+2+3+4+...+100
		// i为循环变量，还充当了1~100之间的每个数
		int i = 1;
		// 可以将1~100之间的每个数都加到sum上，最后sum的值就是最终结果
		int sum = 0;
		//通过循环可以获取到1~100之间的每个数，并用i表示
		while(i<=100){
			//判断i是否为偶数，是偶数则加到sum中，不是则不加
			if(i%2==0){
                //将每次循环的i都加到sum中
				sum += i;				
			}
			//注意：i++必须放在if外面
			i++;
		}
		System.out.println(sum);
	}
}
3. 猜大小
    思路：
    	先获取到一个随机整数n，然后通过黑窗口输入整数m，若m==n，则打印，猜对了，并且游戏结束；
   			若m<n,则打印猜小了，请重新输入；
    		若m>n,则打印猜大了，请重新输入；
class TestGame{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		//java.util包下，Random对象为随机数对象，可以通过该对象方法获取随机数
		Random r = new Random();
		//nextInt(101) 获取0~100之间的随机数
		int n = r.nextInt(101);
		System.out.println("欢迎来到猜大小游戏！！");
		System.out.println("请输入一个0~100之间的整数：");
		
		while(true){
			int m = sc.nextInt();
			if(m==n){
				System.out.println("恭喜你，猜对了！！");
				break;
			}else if(m<n){
				System.out.println("猜小了，请重新输入：");
			}else if(m>n){
				System.out.println("猜大了，请重新输入：");
			}
		}
	}
}

do while循环

语法：

do{
    //循环体
}while(布尔表达式);

执行流程：

1. 先执行一次循环体
2. 再进行布尔表达式（循环条件）的判断，若结果为true，则再次执行循环体
3. 直至结果为false，则结束循环

do while循环的特点：先执行，再判断；不确定性循环，适用于循环次数不明确的场景

案例： 
   同学写作业，老师批改作业，给出评价（true、false）；若为true，则作业完成；若为false，则需要再写一次作业
class TestDoWhile{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		boolean bo;
		do{
			System.out.println("500行代码~~~~");
			System.out.println("请老师批改：");
			bo = sc.nextBoolean();
		}while(!bo);
	}
}

for循环

语法：

for(循环变量;循环条件;循环迭代语句){
    //循环体
}

执行流程：

1. 初始化循环变量（只执行一次）
2. 判断循环条件，若结果为true，则执行循环体；
3. 当循环体执行结束后，执行循环迭代语句
4. 再次判断循环条件，若结果true，则执行循环体
5. …
6. 直至结果为false，结束循环

for循环的特点：先判断，再执行；确定性循环，适用于循环次数明确的场景

//使用for循环，打印10次HelloWorld
class TestFor{
	public static void main(String[] args){
		for(int i=1;i<=10;i++){
			System.out.println("HelloWorld  "+i);
		}
	}
}
//使用for循环计算1~100的和
class TestFor1{
	public static void main(String[] args){
		int sum = 0;
		for(int i=1;i<=100;i++){
			sum += i;
		}
		System.out.println(sum);
	}
}

注意：

1. 循环变量可以省略（或写在上面），;不能少
2. 循环条件可以省略，可能造成死循环
3. 循环迭代语句可以省略，可能造成死循环

总结

1. while\for都是先判断，再执行；do while是先执行，再判断
2. for循环为确定性循环，适用于循环次数明确的场景
3. while和do while为不确定性循环，适用于循环次数不明确的场景
4. 若无论如何都要执行一次，使用do while

流程控制

1. break 跳出或结束当前循环、分支结构

2. continue 跳过本次循环，继续下次循环

   class TestBreak{
   	public static void main(String[] args){
   		for(int i=1;i<=10;i++){
   			if(i==5){
   				break;
   			}
   			System.out.println(i);
   		}
   	}
   }
   class TestContinue{
   	public static void main(String[] args){
   		for(int i=1;i<=10;i++){
   			if(i==5){
   				continue;
   			}
   			System.out.println(i);
   		}
   	}
   }
   

循环嵌套

概念： 在一个循环内部再定义一个循环

注意：

1. 只要语法结构完整，可以无限嵌套；但是一般推荐，只嵌套一层

2. 内层循环体循环次数 = 外层循环次数*内层循环次数

3. break及continue只能作用于直接包含它们的循环结构

4. 循环的标号：在循环的前面给循环起一个名字，该名字即可代表该循环

   class TestForFor{
   	public static void main(String[] args){
   		outer:for(int i=1;i<=10;i++){
   			inner:for(int j=1;j<=10;j++){
   				if(j==5)break outer;
   				System.out.println("i="+i+"  j="+j);
   			}
   		}
   	}
   }
   

5. 应用场景：图形打印、百钱买百鸡、打印乘法口诀表

//百钱买百鸡    100文钱需要买100只鸡   公鸡  3文/只  母鸡  2文/只  小鸡  1文/3只
//请问总共有哪些购买方案
//百钱买百鸡    100文钱需要买100只鸡   公鸡  3文/只  母鸡  2文/只  小鸡  1文/3只
//请问总共有哪些购买方案
/* 
思路：
	公鸡：i(0~33)    母鸡 j(0~50)   小鸡  100-i-j
	3*i+2*j+(100-i-j)/3==100
	
*/
class Test{
	public static void main(String[] args){
		for(int i=0;i<=33;i++){
			int max = (100-i*3)/2;
			for(int j=0;j<=max;j++){
				int k = 100-i-j;
				if(k%3==0&&3*i+2*j+k/3==100){
					System.out.println("公鸡个数："+i+" 母鸡个数："+j+" 小鸡个数："+k);
				}
			}
		}
	}
}

chap04-函数

基本语法

概念：一段具有特定功能的代码，可以重复调用

class TestFunction{
	public static void main(String[] args){
		//20个*组成的分割线
		for(int i=1;i<=15;i++){
			System.out.print("*");
		}
		System.out.println();
		System.out.println("文能挂机喷队友");
		for(int i=1;i<=15;i++){
			System.out.print("*");
		}
		System.out.println();
		System.out.println("武能越塔送人头");
		for(int i=1;i<=15;i++){
			System.out.print("*");
		}
		System.out.println();
		System.out.println("进可孤身一挑五");
		for(int i=1;i<=15;i++){
			System.out.print("*");
		}
		System.out.println();
		System.out.println("退可坐等十五投");
		for(int i=1;i<=15;i++){
			System.out.print("*");
		}
		System.out.println();
	}
}
以上代码存在问题：
    1. 代码冗余     重复的代码写了太多遍
    2. 可维护性差   
    3. 可重用性差
解决办法：将打印分割线的功能写成一个函数，在需要分割线的地方调用函数即可

语法：

public static void 函数名(){
    // 功能代码
}

函数声明：  public static void 函数名()   -- 声明一个函数。一般的，通过声明就可以明白函数的作用
函数实现：  {  功能代码 }    -- 函数功能的具体实现代码
    
例如： 打印分割线函数
    public static void printLine(){
    	for(int i=1;i<=15;i++){
			System.out.print("*");
		}
		System.out.println();
	}

位置： 类的内部，其他函数的外部

//1
class Test{
    //2
    public static void main(String[] args){
    	//3
	}
    //4
}
//5
注意：只有位置2与位置4可以定义函数

调用函数： 通过 函数名(); 即可

注意：

1. 函数定义完成后，必须进行调用，才会实现相应的功能
2. () 不能省略！！！
3. 当程序执行时，遇到函数调用语句，会先暂时离开当前函数，进入到被调用函数中执行代码；当被调用函数中的代码执行完毕后，程序会回到函数调用处，继续向下执行

参数

大多数情况下，函数的顺利执行需要从外界获取数据。在函数声明中，需要告诉外界此函数需要接收什么样的数据；在函数被调用时，函数调用者，就需要根据声明传入相应的数据；

形参：形式参数，定义在函数声明中（），作用： 告诉外界此函数需要什么样的数据

实参：实际参数，写在函数调用中（），作用：根据形参传入相应的实际数据

语法：

public static void 函数名(形参列表){
    //功能代码
}

0个形参：
public static void 函数名(){
    //功能代码
}
1个形参
public static void 函数名(参数类型 参数名){
    //功能代码
}
例如：
    public static void method(int n){}
多个参数：参数之间使用,隔开
public static void 函数名(参数类型1 参数名1，参数类型2 参数名2，...，参数类型n 参数名n){
    //功能代码
}    

调用函数： 函数名(实参列表);

注意：当函数具有形参时，调用该函数时必须根据形参，传入相应的实参（类型、个数、顺序）

经验：形参相当于声明了一个作用范围为整个函数内部的局部变量；实参相当于为形参赋值

单个参数

class TestFunction{
	public static void main(String[] args){
		//20个*组成的分割线
		printLine1(10);
		System.out.println("文能挂机喷队友");
		printLine1(15);
		System.out.println("武能越塔送人头");
		printLine1(20);
		System.out.println("进可孤身一挑五");
		printLine1(25);
		System.out.println("退可坐等十五投");
		printLine1(30);
	}
	//函数：打印不同长度的分割线
	public static void printLine1(int num){
		for(int i=1;i<=num;i++){
			System.out.print("*");
		}
		System.out.println();
	}
	
}

多个参数

class TestFunction{
	public static void main(String[] args){
		//20个*组成的分割线
		printLine2(10,"*");
		System.out.println("文能挂机喷队友");
		printLine2(15,"~");
		System.out.println("武能越塔送人头");
		printLine2(20,"#");
		System.out.println("进可孤身一挑五");
		printLine2(25,"-");
		System.out.println("退可坐等十五投");
		printLine2(30,"=");
	}
	//函数：打印不同长度的分割线
	public static void printLine2(int num,String line){
		for(int i=1;i<=num;i++){
			System.out.print(line);
		}
		System.out.println();
	}
}

返回值

很多时候，函数执行结束后都需要返回一个结果，该结果即返回值！

语法：

public static 返回值类型 函数名(形参列表){
    // 功能代码
    //return 语句
}
注意：
    1. 返回值类型：8种基本数据类型、引用类型、 void(无返回值类型，表示函数没有返回值)
    2. 当返回值类型为8种基本数据类型或引用类型时，在函数实现中，必须书写return语句
    	return语句： return 返回值;  
			作用：表示结束函数，并将返回值返回到函数调用处
    3. 当返回值类型为void时，函数实现中不需要书写return语句！但是，也可以使用return关键字
        return;  表示结束函数！！
    4. return后面的返回值的类型必须和函数声明中定义的返回值类型一致！！

调用函数：

两种方式：
    1. 若需要使用返回值，可以使用变量接收返回值
    	返回值类型 变量名 = 函数名(实参列表)；
    2. 若不需要使用返回值，或者只是简单的使用一次、打印，可以像之前直接调用
    	函数名(实参列表)；
    
class TestFunction2{
	public static void main(String[] args){
		//1. 用变量接收返回值
		// int c = add(1,2);
		// int d = c+2;
		// System.out.println(d);
		//2. 直接调用
		System.out.println(add(1,2));
		add1(2,3);
		//错误写法，由于add1函数没有返回值，所用不能写在输出语句中
		//System.out.println(add1(2,3));
	}
	//需求：定义一个求和函数
	public static int add(int a,int b){
		// int c = a+b;
		// return c;
		return a+b;
	}
	public static void add1(int a,int b){
		System.out.println(a+b);
	}
}

补充： return的用法

用法：

1. 用在具有返回值类型（8种基本数据类型、引用类型）的函数中，必须通过return语句返回相应的值

return 返回值； 表示结束函数，并将返回值返回到函数调用处

2. 用在没有返回值类型（void）的函数中，可以不写return语句；但也可以使用return

return ； 仅仅表示结束函数

class Test{
	public static void main(String[] args){
		Prime(11);
	}
	public static void Prime(int n){
		for(int i=2;i<n;i++){
			if(n%i==0){
				System.out.println(n+"不是质数");
				return;
			}
		}
		System.out.println(n+"是质数");
	}
}
思考：
   1. if后面为什么不写else
   2. return在本代码中的作用

return的使用要求

1. return 语句后面，不能写其他代码
2. 一个代码中，同一时间只能有一个有效的return语句
3. return后面只能跟一个值
4. 若在具有返回值类型的函数中，存在选择、循环结构，必须保证任何情况下都有return语句！

class TestReturn{
	public static void main(String[] args){
		method();
	}
	public static int method(){
		//编译器只能做基本的语法检查，只要写了选择或循环结构，
		//编译器就认为该结构有可能判断为false，从而不执行
		
		/* 
		if(true){
			return 0;
		} 
		*/
		if(true){
			return 0;
		}else{
			return 0;
		}
		//无法访问的代码
		//return 0;
	}
	public static int method1(){
		int a = 10;
		while(a>1){
			return 0;
		}
		return 0;
	}
}

总结

1. 不能在一个函数内部，再定义其他函数
2. 函数三要素：函数名、形参列表、返回值类型
3. 一般的，一个函数只负责一个功能！
4. 函数的优点
   1. 减少代码冗余
   2. 提高代码可读性
   3. 提高代码可维护性
   4. 提高代码可复用性

函数高级

函数嵌套调用

概念： 在一个函数中调用其他函数

class TestFunction3{
	public static void main(String[] args){
		System.out.println("main  start");
		ma();
		System.out.println("main  end");
	}
	public static void ma(){
		System.out.println("ma  start");
		mb();
		System.out.println("ma  end");
	}
	public static void mb(){
		System.out.println("mb  start");
		mc();
		System.out.println("mb  end");
	}
	public static void mc(){
		System.out.println("mc  start");
		System.out.println("mc  end");
	}
}

总结：

1. 嵌套层次最深的函数，最先执行结束
2. 调用函数的形参，可以作为被调用函数的实参

JVM的内存结构（了解）

栈： 是一种只能在顶部进行操作的线性表；即入栈（压栈）和出栈（弹栈）操作都只能对栈顶元素执行

栈的特点： 先进后出，后进先出

栈帧：栈的基本组成元素；每当执行一个函数时，都会自动生成一个栈帧，进入到栈空间中；该栈帧中保存着该函数的所有信息（局部变量表、操作数栈，动态链接、返回地址…）；当函数代码执行结束，会执行出栈操作

递归（了解）

概念： 在函数内部调用自身函数（俗称：自己调自己）

作用： 可以高效的解决某些特定场景下的问题

注意：所有能够使用递归的场景，都可以通过循环代替

何时才能使用递归：

• 当大问题可以拆分为小问题，并且大小问题解决方式相同

  例如：计算阶乘：  5！=5*4*3*2*1  4!=4*3*2*1  5!=5*4!
  

//递归  自己调自己
class TestDiGui{
	public static void main(String[] args){
		System.out.println("main  start");
		ma();
		System.out.println("main  end");
	}
	public static void ma(){
		System.out.println("ma  start");
		ma();
		System.out.println("ma  end");
	}
}
存在问题：无穷递归，导致栈溢出，程序运行终止
解决问题：设定正确的出口条件（回归条件）

//定义函数，接收一8以内的整数，计算其阶乘：
//for循环计算阶乘
class TestJieCheng{
	public static void main(String[] args){
		System.out.println(ma(3));
	}
	public static int ma(int n){
		int result = 1;
		for(int i=n;i>=1;i--){
			result *= i;
		}
		return result;
	}
}
//递归版计算阶乘
class TestJieCheng1{
	public static void main(String[] args){
		System.out.println(ma(3));
	}
	//ma(n) 计算出n的阶乘  n!= n*(n-1)！  ===》 n! = n*ma(n-1)
	/* 
		ma(n-1)  计算出n-1的阶乘
	*/
	public static int ma(int n){
		if(n==0||n==1) return 1;
		return n*ma(n-1);
	}
}

chap05-数组

概念： 是内存中一块连续的存储空间。可以存储多个相同类型的值，相当于声明了多个相同类型的变量

注意： 数组的长度是固定的、不可变的

创建数组

• 第一种方式

  先声明： 数据类型[] 数组名;    例如： int[] arr;
  再分配空间: 数组名 = new 数据类型[长度];   例如：arr = new int[5];
  

• 第二种方式 推荐使用

  声明的同时分配空间：数据类型[] 数组名 = new 数据类型[长度]; 
  例如： int[] arr = new int[5];
  

• 第三种方式 推荐使用

  声明并初始化： 数据类型[] 数组名 = {值1，值2，值3，....}；
  例如： int[] arr = {1,2,3,4,5};
  注意： 声明与初始化不能分开！！！
      int[] arr;
  	arr = {1,2,3,4,5};//错误语法！
  

• 第四种方式

  声明并初始化： 数据类型[] 数组名 = new 数据类型[]{值1，值2，值3，....}；
  例如： int[] arr = new int[]{1,2,3,4,5};
  注意：数组长度与初始化不能同时出现！！
      int[] arr = new int[5]{1,2,3,4,5};//错误语法
  

补充： 数组数据类型的写法

1. 数据类型[] 数组名;
2. 数据类型 []数组名;
3. 数据类型 数组名[];
推荐使用第一种！！

使用数组

1. 数组长度： 数组的长度是固定的，通过 数组名.length 可以获取到

2. 数组下标： 数组中的每个存储空间都有一个默认的标号，即下标；

   下标范围： 0~length-1

3. 数组元素： 数组中的每个存储空间都为元素！

4. 元素访问： 通过数组下标，可以访问到数组中的每个元素；

   ? 取值： 数组名[下标]; 赋值： 数组名[下标] = 值；

class TestArray{
	public static void main(String[] args){
		//4种创建语法
		//1.
		// int[] arr1;
		// arr1 = new int[5];
		//2.
		// int[] arr2 = new int[5];
		//3.
		// int[] arr3 = {1,2,3,4,5};
		//4.
		// int[] arr4 = new int[]{1,2,3,4,5};
		
		int[] arr = new int[5];
		
		//赋值操作
		arr[0] = 1;
		arr[1] = 2;
		arr[2] = 3;
		arr[3] = 4;
		arr[4] = 5;
		// 运行报错：java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常
		//arr[5] = 6;
		
		//取值操作
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		System.out.println(arr[3]);
		System.out.println(arr[4]);
		System.out.println(arr.length);

	}
}

5. 数组具有默认值，即数组的数据类型的默认值

   数据类型	默认值
   整数类型	0
   浮点数类型	0.0
   字符类型	0或‘\u0000’所对应的字符–空字符
   布尔类型	false
   引用类型	null

6. 遍历数组： 通过下标逐个访问数组中的每个元素；需要借助for循环，获取每个数组下标，此时循环变量不仅仅控制循环次数，还要充当数组下标

   class TestArray{
   	public static void main(String[] args){
   		
   		int[] arr = {1,2,3,4,5};
   		
   		//遍历数组
   		for(int i=0;i<arr.length;i++){
   			System.out.println(arr[i]);
   		}
   	}
   }
   

深入数组底层

1. 数组属于引用类型
2. 数组引用（数组名）中存储的是数组首元素地址（首地址）
3. 寻址公式： 首元素地址+下标*数组数据类型字节长度
4. 数组下标为什么从0开始？答： 为了提高寻址效率！！
5. 数组变量之间相互赋值，传递的是地址（首元素地址）

class TestArray1{
	public static void main(String[] args){
		//在当前栈帧中开辟一块空间叫做a,里面存储一个整数10
		int a = 10;
		//在当前栈帧中开辟一块空间叫做b
		int b = a;//将空间a中值，赋值(复制)给空间b
		System.out.println(b);//10
		
		b++;
		//当完成了b=a这样的赋值操作后，a与b之间就不存在联系了，a与b是相互独立的
		//所以b的变化，不会导致a变化
		System.out.println(a);//10 
		
		//在当前栈帧中开辟一块空间叫做arr,里面存储一个数组的首元素地址
		//数组对象存储在堆空间中，arr中的地址可以指向堆空间中的数组对象
		int[] arr = {1,2,3,4,5};
		//在当前栈帧中开辟一块空间叫做brr
		//将空间arr中的数组地址，赋值给空间brr，
		//此时arr与brr中的地址相同，即指向堆空间中同一数组对象
		int[] brr = arr;
		System.out.println(brr[0]);//1
		
		brr[0]++;
		//由于arr与brr实际指向的是同一数组对象，
		//所以无论是arr还是brr，只要修改了数组内容，另一个引用都可以看到变化
		System.out.println(arr[0]);//2
	}
}

class TestArray2{
	public static void main(String[] args){
		int a = 10;
		int[] arr = {1,2,3,4,5};
		ma(a,arr);
		System.out.println(a);//10 
		System.out.println(arr[0]);//2
	}
	public static void ma(int b,int[] brr){
		b++;
		brr[0]++;
	}
	
}

数组“扩容”

原理：

1. 新建一个更大的数组
2. 将旧数组中的数据一一复制到新数组中
3. 将新数组的地址赋值给旧数组的引用

具体实现方式

1. 使用for循环

   class TestArray3{
   	public static void main(String[] args){
   		int[] arr = {1,2,3,4,5};
   		//1.新建一个更大的数组
   		int[] brr = new int[arr.length*2];
   		//2.将旧数组中的值一一复制到新数组中
   		for(int i=0;i<arr.length;i++){
   			brr[i] = arr[i];
   		}
   		//3.将新数组的地址赋值给旧数组引用
   		arr = brr;
   		//遍历数组
   		for(int i=0;i<arr.length;i++){
   			System.out.println(arr[i]);
   		}
   	}
   }
   

2. 使用System类中的数组扩容方法arraycopy(…);

   class TestArray4{
   	public static void main(String[] args){
   		int[] arr = {1,2,3,4,5};
   		//1.新建一个更大的数组
   		int[] brr = new int[arr.length*2];
   		//2.将旧数组中的值一一复制到新数组中
   		//System.arraycopy(旧数组名,旧数组复制起始下标,新数组名,新数组起始下标,复制长度);
   		System.arraycopy(arr,0,brr,0,arr.length);
   		//3.将新数组的地址赋值给旧数组引用
   		arr = brr;
   		//遍历数组
   		for(int i=0;i<arr.length;i++){
   			System.out.println(arr[i]);
   		}
   	}
   }
   

3. 借助数组工具类Arrays实现扩容

   class TestArray5{
   	public static void main(String[] args){
   		int[] arr = {1,2,3,4,5};
   		//Arrays.copyOf(旧数组名,被返回的新数组的长度);
   		arr = java.util.Arrays.copyOf(arr,arr.length*2);
   		//遍历数组
   		for(int i=0;i<arr.length;i++){
   			System.out.println(arr[i]);
   		}
   	}
   }
   

思考：如何实现缩容？？

答：只需要将新建的大数组改为小数组即可！

可变长参数（了解）

概念：定义形参时，参数的个数可以不确定；当调用函数时，由传递的实参个数决定

语法：

public static 返回值类型 函数名(数据类型... 参数名){
    //函数实现
}

注意：每个函数最多只能定义一个可变长参数，并且必须要定义在形参列表末尾

使用可变长参数：可以将可变长参数当做数组来使用

class Test{
	public static void main(String[] args){
		print(1,2,3,4);
		System.out.println("===========");
		print(11,12,13,14,15);
	}
	public static void print(int... a){
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
		}
	}
}

二维数组

概念：一维数组的元素还是一维数组

创建语法

1.  先声明：  数据类型[][] 数组名；  例如： int[][] arr;
    后分配空间： 数组名 = new 数据类型[高维数组长度][低维数组长度];  例如：arr = new int[4][2];
2.  声明并分配空间：数据类型[][] 数组名 = new 数据类型[高维数组长度][低维数组长度];
	例如： int[][] arr = new int[4][2];
3.  声明并初始化： 数据类型[][] 数组名 = {{值1,值2,值3},{值1,值2},{值1},....{}};
	例如： int[][] arr = {{1,2,3},{4,5},{6,7,8,9,0}};
4.  创建不规则二维数组：
    	数据类型[][] 数组名 = new 数据类型[高维数组长度][];
		数组名[高维数组下标] = new 数据类型[低维数组长度];
		数组名[高维数组下标] = new 数据类型[低维数组长度];
		...
    例如：
        int[][] arr = new int[4][];
		arr[0] = new int[2];   arr[0] = {1,2};//错误语法
		arr[1] = new int[3];   arr[1] = new int[]{3,4,5};//正确语法
		arr[2] = new int[1];
		arr[3] = new int[5];

使用数组

通过 数组名[高维数组下标] 可以获取到相应的低维数组
通过 数组名[高维数组下标][低维数组下标] 可以获取到相应的低维数组中相应的下标所对应的元素

数组遍历：需要使用双重for循环

class TestArray1{
	public static void main(String[] args){
		int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
		
		//遍历二维数组
		//外层for循环获取到所有的低维数组，循环变量充当高维数组下标
		for(int i=0;i<arr.length;i++){
			//内层for循环获取到相应低维数组的所有元素，循环变量充当低维数组下标
			for(int j =0;j<arr[i].length;j++){
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
	}
}
// 查找二维数组中的最大值与最小值，不使用排序
class TestArray2{
	public static void main(String[] args){
		int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
		
		int max = arr[0][0];
		int min = arr[0][0];
		
		for(int i=0;i<arr.length;i++){
			for(int j =0;j<arr[i].length;j++){
				if(arr[i][j]>max) max = arr[i][j];
				if(arr[i][j]<min) min = arr[i][j];
			}
		}
		System.out.println(min+"  "+max);
	}
}
// 计算二维数组的总和
class TestArray3{
	public static void main(String[] args){
		int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
		int sum = 0;
		
		for(int i=0;i<arr.length;i++){
			for(int j =0;j<arr[i].length;j++){
				sum += arr[i][j];
			}
		}
		System.out.println(sum);
	}
}

数组排序

冒泡排序

概念： 使数组中相邻的两个元素比较大小，根据需求决定是否交换位置

class TestArraySort{
	public static void main(String[] args){
		int[] arr = {9,6,3,7,2};
		
		/* 
			冒泡 完成升序排序  从小到大
			目标：2 3 6 7 9
			
				9  6  3  7  2
		下标   	0  1  2  3  4
	
	第一次冒泡  i=1    j=0;j<length-1;j++
		j~j+1
		0~1		6  9  3  7  2
		1~2		6  3  9  7  2
		2~3     6  3  7  9  2
		3~4     6  3  7  2  9
	结果：找出了最大值，并且放在了最右边（4下标）
	
	第二次冒泡  i=2    j=0;j<length-2;j++
		0~1		3  6  7  2  9
		1~2		3  6  7  2  9
		2~3		3  6  2  7  9
	结果：找出了第2大值，并且放在了3下标上
	
	第三次冒泡  i=3    j=0;j<arr.length-i;j++
		0~1		3  6  2  7  9
		1~2		3  2  6  7  9
	结果：找出了第3大值，并且放在了2下标上
	
	第四次冒泡
		0~1		2  3  6  7  9
	结果：找出了第4大值及最小值，并且放在了相应下标上
	
	冒泡次数：length-1次
	实现方式：双重for循环
		外层for循环: 控制冒泡次数 
			for(int i=1;i<arr.length;i++)
		内层for循环：控制相邻元素比较
			for(int j=0;j<arr.length-i;j++)

		*/
		for(int i=1;i<arr.length;i++){
			for(int j=0;j<arr.length-i;j++){
				if(arr[j]>arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		//遍历
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

选择排序

概念： 每次选择，都固定一个元素，逐个与其他所有元素比较大小，根据需求决定是否交换位置

class TestArraySort2{
	public static void main(String[] args){
		int[] arr = {9,6,3,7,2};
		
		/* 
			选择 完成升序排序  从小到大
			目标：2 3 6 7 9
			
				9  6  3  7  2
		下标   	0  1  2  3  4
	
	第一个选择  i=0   j=1;j<arr.length;j++
		i~j
		0~1		6  9  3  7  2
		0~2		3  9  6  7  2
		0~3		3  9  6  7  2
		0~4		2  9  6  7  3
	结果：找出了最小值，放在了最左边（0下标）
	
	第二次选择	i=1   j=2;j<arr.length;j++
		1~2		2  6  9  7  3
		1~3     2  6  9  7  3
		1~4		2  3  9  7  6
	结果：找出了第2小值，放在了1下标
	
	第三次选择	i=2   j=i+1;j<arr.length;j++
		2~3     2  3  7  9  6
		2~4		2  3  6  9  7
	结果：找出了第3小值，放在了2下标
	
	第四次选择
		3~4		2  3  6  7  9
	结果：找出了第4小值及最大值，放在了相应下标
	
	选择次数：length-1
	实现方式：双重for循环
		外层for循环：控制每次选择所固定的元素下标
			for(int i=0;i<arr.length-1;i++)
		内层for循环：控制每次选择中的其他所有元素下标
			for(int j=i+1;j<arr.length;j++)
		*/
		
		for(int i=0;i<arr.length-1;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		
		//遍历
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

JDK排序

概念：借助数组工具类Arrays中的排序方法sort完成排序

注意：只能做升序排序！！

class TestArraySort3{
	public static void main(String[] args){
		int[] arr = {9,6,3,7,2};
		java.util.Arrays.sort(arr);
		//遍历
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

chap06-面向对象

编程思想

概念：建立解决问题的思路，即编程思想

常见的编程思想

1. 面向过程： 自顶向下，逐步求精，注重解决问题的过程，将解决问题分为一个一个的步骤，只要按照步骤执行就一定能解决问题
2. 面向对象： 分析解决问题需要的哪些功能，而哪些对象具有这种功能；注重对象之间的配合调用

问题： 回家

面向过程： 拿着地图，分析回家需要经过哪些路口，每条路上走多远，遇到路口往哪儿拐，一步一步就走到家了

面向对象：只需要调用出租车（对象）的载客功能，由出租车送我们回家

注意：面向对象与面向过程并不是完全对立！面向对象是在面向过程的基础上实现的

面向对象

认识对象

什么是对象？

Java眼中的对象： 一切客观存在的事物都是对象！世界就是由对象组成的！—万物皆对象

? 例如：水杯、桌子、电脑、空气、错误等等都是对象

程序中的对象： 内存中的一块存储空间，用来存储对现实对象的关注的部分，从而代表现实中的对象

• 对象的组成：

  • 特征（属性）： 有什么
  • 行为（方法）： 干什么

  注意：有时候，一个对象的属性可能也是一个对象；对象的调用者可能也是一个对象
  例如：硬盘是电脑的属性，硬盘本身也是对象；程序员使用电脑开发，程序员也是对象
  

• 对象间的关系

  • 一个对象继承了另一个对象 is a 例如：狗是一个动物
  • 小对象组成大对象 has a 例如：电脑由硬盘、cpu组成
  • 一个对象使用另一个对象 use a 例如：程序员使用电脑

重新认识类

类与对象的关系

1. 类是对象的模板
2. 类是人们对一系列相同相似事物（现实中的对象）的认识，抽取出共性定义在类中
3. 对象就是根据类创建出来的实例，类似于根据模板生产物品

4. 类由属性与方法组成

例如： Computer类 ------》电脑对象

类的组成

1. 属性： 有什么 成员变量\实例变量

   位置： 类的内部，方法的外部

   语法：

   1. 声明属性： 数据类型 属性名;    例如：String name;
   2. 声明并初始化： 数据类型 属性名 = 值；  例如： int age = 18;
   
   错误语法： 先声明，再赋值
       例如： double score;
   		  score = 100;//错误语法！！
   
   class Student{
   	String name;
   	int age = 18;
   	double score;
   	//score = 100;错误
   }
   

   属性具有默认值：即属性的数据类型的默认值！

   属性的作用范围：至少为整个类的内部

   注意：当属性与局部变量命名冲突，局部变量优先！

   补充：局部变量与属性的区别

   	局部变量	属性
   位置	定义在函数（方法）内部	类的内部，方法的外部
   默认值	没有默认值	具有默认值
   作用范围	从定义的那一行开始，到定义所在代码块的结束	至少整个类的内部
   命名冲突	作用范围重合内，不允许命名重复	当属性与局部变量命名冲突，局部变量优先

2. 方法： 干什么 成员方法 对象的具体的行为：吃喝拉撒睡、工作、学习、玩耍、等等

   位置： 类的内部，其他方法的外部

   语法：

   修饰符 返回值类型 方法名(形参列表){
   	//方法实现
   }
   注意：函数是特殊的方法！函数声明中需要写上static修饰符；而方法一般不写static
   
   class Student{
   	String name = "小郭";
   	int age = 18;
   	double score;
   	//score = 100;错误
   	
   	public void study(){
   		//局部变量优先！
   		//String name = "小红";
   		System.out.println(name+"沉迷学习无法自拔");
   	}
   	public void eat(){
   		System.out.println("吃饭饭");
   	}
   	public void sleep(){
   		System.out.println("睡觉觉");
   	}
   }
   

3. 构造方法： Java规定的具有特殊功能的方法

   作用： 可以用来配合new关键字创建对象，并且可以在创建对象的过程中选择是否为对象属性赋值！

   分类：

   • 无参构造方法 没有形参列表，在创建对象时无法为对象属性赋值；可以在对象创建成功后，通过其他方式赋值

     语法： public 类名(){}

   • 有参构造方法 具有形参列表，在创建对象时可以将形参的值赋值给属性

     语法： public 类名(形参列表){ //赋值语句 }

   注意：

   1. 构造方法的方法名必须和类名相同！
   2. 构造方法没有返回值类型，注意连void都没有
   3. 构造方法无法手动调用，只有在创建对象时被调用一次
   4. 若代码中没有定义任何构造方法，默认提供一个公开无参构造方法

   经验：

   1. 一般的，若类中具有属性，需要提供有参、无参构造方法
   2. 可以定义多个形参个数不同的有参构造方法

   //学生类
   class Student{
   	//属性
   	String name = "小红";
   	int age = 18;
   	double score;
   	//score = 100;错误
   	//普通的行为方法
   	public void study(){
   		//局部变量优先！
   		//String name = "小郭";
   		System.out.println(name+"沉迷学习无法自拔");
   	}
   	public void eat(){
   		System.out.println("吃饭饭");
   	}
   	public void sleep(){
   		System.out.println("睡觉觉");
   	}
   	
   	//无参构造方法
   	public Student(){}
   	//具有两个参数的有参构造方法
   	public Student(String n,double s){
   		name = n;
   		score = s;
   	}
   	//具有三个参数的有参构造方法
   	public Student(String n,int a,double s){
   		name = n;
   		age = a;
   		score = s;
   	}
   }
   

   思考：普通方法与构造方法的区别？

   答： 普通方法是人为定义的一些具体功能、行为方法，例如吃喝拉撒睡、工作学习等等

   而构造方法它的作用是Java实先规定好的，是用来创建对象的；它们的关系就好像主函数与普通函数的关系

创建对象

创建对象的方式：

1. 通过无参构造方法创建对象

   语法： 类名 引用 = new 类名(); 例如：Student s1 = new Student();

2. 通过有参构造方法创建对象

   语法： 类名 引用 = new 类名(实参列表); 例如：Student s2 = new Student(“小郭”,20,80);

使用对象：

• 使用对象的属性：
  • 通过 引用.属性名; 获取该对象的该属性
  • 通过 引用.属性名 = 值； 完成对该对象的该属性的再次赋值
• 使用对象的方法：
  • 通过 引用.方法名(实参列表) 调用该对象的该方法

class TestObject{
	public static void main(String[] args){
		//通过无参构造方法创建对象
		Student s1 = new Student();
		System.out.println(s1.name+" "+s1.age+" "+s1.score);
		s1.study();
		s1.score = 100;
		System.out.println(s1.name+" "+s1.age+" "+s1.score);
		
		//通过有参构造方法创建对象
		Student s2 = new Student("小郭",20,80);
		System.out.println(s2.name+" "+s2.age+" "+s2.score);
		s2.study();

	}
}
//学生类
class Student{
	//属性
	String name = "小红";
	int age = 18;
	double score;
	//score = 100;错误
	//普通的行为方法
	public void study(){
		//局部变量优先！
		//String name = "小郭";
		System.out.println(name+"沉迷学习无法自拔");
	}
	public void eat(){
		System.out.println("吃饭饭");
	}
	public void sleep(){
		System.out.println("睡觉觉");
	}
	
	//无参构造方法
	public Student(){}
	//具有两个参数的有参构造方法
	public Student(String n,double s){
		name = n;
		score = s;
	}
	//具有三个参数的有参构造方法
	public Student(String n,int a,double s){
		name = n;
		age = a;
		score = s;
	}
}

方法重载（OverLoad）

概念：允许一个类中定义多个同名的方法，比如，构造方法

语法要求：

1. 方法名必须相同
2. 形参列表必须不同（个数、类型、顺序不同，仅仅形参名不同，不算重载）
3. 修饰符、返回值类型、异常不作要求

使用重载方法：编译器在编译时，会根据实参列表选择调用相应的重载方法，采用就近向上匹配原则

方法重载的好处：对于方法调用者，屏蔽了多个功能相同相似，只是形参不同的方法的差异；方便调用者调用方法

class TestCounter{
	public static void main(String[] args){
		Counter1 c1 = new Counter1();
		
		System.out.println(c1.addInt(1,2));
		System.out.println(c1.addDouble(1.5,2.5));
		System.out.println(c1.addIntAndDouble(1,2.5));
		System.out.println(c1.addDoubleAndInt(1.5,2));
		
		Counter2 c2 = new Counter2();
		
		System.out.println(c2.add(1,2));
		System.out.println(c2.add(1.5,2.5));
		System.out.println(c2.add(1,2.5));
		System.out.println(c2.add(1.5,2));
	}
}
//创建计算器类，可以完成一些数学运算
//未使用方法重载
class Counter1{
	
	public int addInt(int a,int b){
		return a+b;
	}
	public double addDouble(double d1,double d2){
		return d1+d2;
	}
	public double addIntAndDouble(int a,double d){
		return a+d;
	}
	public double addDoubleAndInt(double d,int a){
		return a+d;
	}
}
//方法重载
class Counter2{
	
	public int add(int a,int b){
		return a+b;
	}
	public double add(double d1,double d2){
		return d1+d2;
	}
	public double add(int a,double d){
		return a+d;
	}
	public double add(double d,int a){
		return a+d;
	}
}

就近向上匹配原则：

class TestJavaKid{
	public static void main(String[] args){
        int a = 10;
		JavaKid jk = new JavaKid();
		int n = 1;
		jk.study(n);
		//方法重载特殊情况：对方法引用不明确
		jk.study(1,2);
	}
}
class JavaKid{
	public void study(byte n){
		System.out.println("byte");
	}
	public void study(short n){
		System.out.println("short");
	}
	// public void study(int n){
		// System.out.println("int");
	// }
	// public void study(long n){
		// System.out.println("long");
	// }
	public void study(float n){
		System.out.println("float");
	}
	public void study(double n){
		System.out.println("double");
	}
    // public void study(int n,int i){
		// System.out.println("int -- int");
	// }
	public void study(int i,double n){
		System.out.println("int -- double");
	}
	public void study(double n,int i){
		System.out.println("double -- int");
	}
}