1.第一个程序
1.java程序编写-编译-运行过程
编写：我们将编写的java代码保存在以“.java”结尾的源文件中
编译：使用javac命令编译我们的java源文件。格式：javac 源文件名.java
运行：使用java命令解释运行我们的字节码文件。格式：java 类名
2.在一个java源文件中可以声明多个class。但是最多有一个类声明public的
而且声明public的类的类名必须和源文件名相同。
3.程序的入口是main()方法，格式是固定的。
4.输出语句
System.out.println();先输出数据，然后换行
System.out.print();不换行
5.每一行执行语句都以“;"结束
6.编译的过程：编译以后每个类都会生成一个字节码文件，与类名相同。
2.注释
1.单行注释：//
2.多行注释：
单行注释和多行注册不参与程序编译。
3.多行注释：文档注释（java特有）；注释内容可以被JDK提供的工具javadoc所解析，；生成一套以网页文件形式体现的该程序的说明文档。
3.计算机机制转换
对于整数，有四种表示方式：
1.二进制(binary):0,1,满2进1，以0b或0B开头；
2.十进制(decimal):0-9,满10进1；
3.八进制（octal）：0-7，满8进1，以数字0开头表示 十六进制（hex）：0-9及A-F，满16进1，以 0x或0X开头表示，此处A-F不区分大小写：0x21AF + 1 = 0x21B0；
4.计算机底层以补码方式存储数据。
4.标识符的使用
1.标识符：凡是自己可以起名字的地方都叫做标识符。
比如：类名、变量名、方法名、接口名、包名...
2.标识符的命名规则：
有26个英文字母大小写、0-9、_或$组成；数字不可以开头；不可以使用关键字和保留字，但能包含关键字和保留字；Java中严格区分大小写，长度无限制；标识符不能包含空格。
3.Java中的名称命名规范；
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名、：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxYyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
4.注意：起名字时，为提高阅读性，应“见名知义”。
5.变量的使用
1.Java定义变量的格式：数据类型 变量名 = 变量值;
变量需要先声明和赋值，在使用
变量都定义在其作用域内。在作用域内，他是有效的，出来作用域，变量就失效了。
同一个作用域内，不能声明两个一样的变量。
//变量的定义 int myAge = 12; //变量的使用 System.out.println(myAge); //变量声明 int myNumber; //变量赋值 myNumber = 100;
6.Java数据类型
Java定义的数据类型
1.变量按照数据类型来分
基本数据类型：
整形：byte / short / int / long；浮点型：float /doubl；字符型：char；布尔型： boolean
引用类型数据类型：
类(class)；接口(interface)；数据(array[])
2.变量在类中声明的位置
成员变量 vs 局部变量
整形：byte(1字节 = 8bit） / short(2字节） / int(4字节） / long(8字节）； byte的范围：-128-127
声明long类型变量，必须以“l”或“L"结尾；浮点型：float(4字节)/double(8字节)；浮点型表示带小数点的数值；float表示数值的范围比long还大；定义float类型变量，变量末尾要加上"f"或"F"；通常定义浮点类型变量，使用double类型，更精确；字符型：char (1字符 = 2字节)；定义char类型变量，通常使用一对''，内部只能写一个字符；布尔型：boolean；只能取两个值：true/false；常常在条件判断和循环结构中使用
7.基本数据类型的运算规则
前提：这里只是7中基本数据类型变量间的运算。不包含boolean类型的。
1.自动类型提升
byte/char/short --> int --> long --> float --> double
当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
特别的：当byte、char、short三种类型做运算时，结果为int类型。
2.强制类型转换：自动提升运算的逆运算。
需要使用强转符：()
注意点：强制类型转换，会导致精度损失
//编译不通过
//整形常量默认为int类型，浮点类型常量默认为double类型
//byte = b1 + i1;
int i2 = b1 + i1;
double d1 = 12.3;
int a1 = (int)d1;//截断操作，只要整数，损失精度
//编码成功，默认把int类型赋值给long类型
long l1 = 123231;
//编译失败，过大的整数
//long l2 = 123435467889;
long l3 = 123435467889L;
8.String类型变量的使用
1.String属于引用数据类型，翻译为：字符串
2.声明String类型变量是，使用一对""
3.String可以和8种基本数据类型做运算，只能做连接运算:+
4.运算结果仍然是String类型。
//char = "";//编译不通过 //String str6 = 123;//编译不通过 String str8 = 123 + "";//"123" char c = 'a';//97 A:65 int num = 10; String str = "hello"; System.out.println(c + num + str);//107hello System.out.println(c + str + num);//ahello10
9.运算符
算数运算符：+ - * / % (前)++ (后)++ (前)-- (后)-- ：
赋值运算符：= += -= *= /= %=
// %:取余运算
// 结果的符号和被模数的符号相同
// 开发中，用来判断是否能除进
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 =" + m1 % n1);//2
int m4 = -12;
int n4 = 5;
System.out.println("m4 % n4 =" + m4 % n4);//-2
//(前)++:先自增1，在运算
//(后)++：先运算，在自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);
//注意点
short s1 = 10;
//s1 = s1 + 1;//编译失败
s1 = (short)(s1 + 1);//正确的
s1++;//自增1不会改变本身变量的数据类型
short h1 = 10;
//h1 = h1 +2;//编译不通过
h1 += 2;//不会改变变量本身的数据类型
比较运算符：== != < > <= >= instanceof
结论：比较运算符的结果为boolean类型
区分 == 和 =
逻辑运算符：== && || ！=
位运算符：(&,^,|)化为二进制进行计算
结论：
1.位运算符操作的都是整数的数据
2.<<:再一定范围内，每向左1位，相当于*2
>>:再一定范围内，每向右移1位，相当于/2
面试题：最高效方式的计算2 * 8 ？ 2 << 3 或 8 <<1
System.out.println(i == j);//false
System.out.println(i = j);//20
//区分& 和&&，两者的运算结果相同，当左边为true二者右边都执行
//&&左边为false，右边不再执行；&不管左边成不成立，右边都执行
//区分：| 与 ||，二者运算结果相同，二者左边为false，右边都会执行
//二者左边为ture，|还会运算右边，||不会运算右边
boolean b2 = true;
b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("我现在北京");
}else {
System.out.println("我现在南京");
}
//交换两个的值
//方式一：定义临时变量的方式
//推荐方式
int temp = num4;
num4 = num3;
num3 = temp;
//方式二：好处，不用定义临时变量
//弊端①相加操作可能存在超出存储范围②局限性：只是用数值类型
num3 += num4;
num4 = num3 -num4;
num3 = num3 - num4;
//方式三：使用位运算，好处，不用定义临时变量，局限性：只是用数值类型
num3 = num3 ^ num4;
num4 = num3 ^ num4;
num3 = num3 ^ num4;
三元运算符：结构(条件表达式)？表达式1 ： 表达式2
说明：
①条件表达式的结果是boolean类型
②根据条件表达式真或假，决定执行表达式1，还是表达式2
如果表达式为true，则执行表达式1，(表达式为false)否则执行表达式2
③表达式1和表达式2要求是一致的。
④三维运算符可以嵌套使用。
3.凡是可以使用三元运算符的地方都能使用if(){}else{}
反之不成立。
4.如果程序即可以用三元运算符，又可以使用if-esle结构，优先选择三元运算符
// 获取较大的值 int m = 15; int n = 20; // (m > n)? 2 : "n大";编译错误 int max = (m > n) ? m : n;
10. 流程控制语句（if-else）
分支结构中的if-else(条件判断语句
一、三种结构
第一种：
if(条件表达式){
}
第二种：二选一
if(条件表达式){
执行表达式1;
}else{
执行表达式2;
}
第三种：多选一
f(条件表达式){
执行表达式1;
}else if(条件表达式){
执行表达式2;
}
...
else{
执行表达式n;
}
//举例
int heartBeat = 79;
if(heartBeat < 60){
System.out.println("进一步检查");
}else if(heartBeat > 100){
System.out.println("尽快去检查");
}else {
System.out.println("检查结束");
}
说明：if-else结构可以嵌套使用；if-else结构只有一条可以省略括号
1.else的是可选的
2.针对条件表达是：
如果多个条件表达式之间是”互斥“（或没有交集的关系），那个判断和执行语句声明在上面还是下面，无所谓。
如果多个条件表达式之间有交集关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
Scanner input = new Scanner(System.in);
System.out.println("请输入三个整数：");
int num1 = input.nextInt(), num2 = input.nextInt(), num3 = input.nextInt();
int temp;
if(num1 >= num2){
if(num3 >= num1){
System.out.println(num3+","+num1+","+num2);
}else if(num3 <= num2){
System.out.println(num1+","+num2+","+num3);
}else {
System.out.println(num1+","+num3+","+num2);
}
}else {
if(num3 >= num2){
System.out.println(num3+","+num2+","+num1);
}else if(num3 <= num1){
System.out.println(num2+","+num1+","+num3);
}else {
System.out.println(num2+","+num3+","+num1);
}
}
11.Scanner和Random
如何从键盘获取不同类型的变量，需要使用Scanner类
具体实现步骤：
1.导包：impot java.util.scanner
2.Scanner的实例化:Scanner scan = new Scanner(System.in);
3.调用Sccanner类的相关方法（next() / nextXxx()），来获取指定类型的变量
注意：
需要根据相应的方法，来输入指定类型的值，如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchExcetion导致程序终止。
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("输入你的名字：");
String name = input.nextLine();
System.out.println("请入你的年龄：");
int age = input.nextInt();
System.out.println("请入你的体重：");
double weight = input.nextDouble();
System.out.println("请入你的是否看中我(false/true)：");
boolean blean = input.nextBoolean();
System.out.println("名字："+name+"t年龄："+age+"t体重："+weight+"t看中:"+blean);
}
//获取一个随机数：10-99
int value = (int)(Math.random()*90 + 10);//[0.0,1.0]-->[0.0,90]-->[10-99]
System.out.println(value);
//公式随机数区间：[a,b]:(int)(Math.random() * (b - a + 1) + a)
12.Switch-case
1.格式
switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句2;
//break;
...
default:
执行语句n:
//break;
}
2.说明
①根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应的case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直遇到break关键字或此switch-case结构
末尾为止结束。
②break，可以使用再switch-case结构中，表示一旦执行此关键字，就跳出switch-case结构。
③switch结构的表达式，只能是如下的六种数据类型之一：
byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）
④case之后只能声明常量，不能声明范围
⑤break关键字是可选的。
⑥default：相当于if-else结构中的else，default结构是可选的，位置是灵活的。
⑦如果switch-case结构中的多个case的执行语句相同，则可以考虑合并。
说明：
1.凡是可以使用switch-case的结构，都可以转化为if-else。反之，不成立。
2.我们写分支结构时，当发现既可以使用switch-case，（同时，switch表达式的取值情况不太多）。又可以使用
if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。
//输入年、月、日，判断是当年第几天
Scanner input = new Scanner(System.in);
System.out.println("请输入年份");
int year = input.nextInt();
System.out.println("请输入月份");
int month = input.nextInt();
System.out.println("请输入日期");
int day = input.nextInt();
int sumDays = 0;
switch (month) {
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
//sumDays += 28;
if((year % 4 == 0 && year % 100 != 0)||year % 400 == 0){
sumDays += 29;
}else {
sumDays += 28;
}
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println(year+"年"+month+"月"+day+"日是第"+sumDays+"天");
}
13.for
For循环结构的使用
一、循环结构的4个要素
①初始化条件
②循环条件 ---->是boolean类型
③循环体
④迭代条件
二、for循环的结构
for(①;②;④){
③}
执行过程：①-②-③-④-②-③-④-...-②
int sum = 0;
int count = 0;
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
}
System.out.println(sum+","+count);
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明再另一个循环结构B的循环体中，构成了嵌套循环
2.外层循环：循环结构B
循环结构A
3.内层循环便利一遍，只相当于外层循环体执行了一次
4.外层循环循环m次，内层循环n次，总共执行了m*n次
5.外层控制行数，内存控制列数
for(int i = 0;i < 6;i++){
for(int j = 0;j < i;j++){
System.out.print("*");
}
System.out.println();
}
14.while循环
while循环结构的使用
一、循环结构的4个要素
①初始化条件
②循环条件 ---->是boolean类型
③循环体
④迭代条件
二、while循环的结构
①
while(②){
③;
④;}
执行过程：①-②-③-④-②-③-④-...-②
说明：1.写while循环前往小心不要丢了迭代条件。一旦丢了，可能导致死循环；
2.写程序避免死循环
3.for循环和while循环可以相互转换
区别:for和while循环的初始化条件部分的作用范围不同
int number = 1;
while(number <= 100){
if(number % 2 == 0){
System.out.println(number);
}
number++;
}
15.do-while循环的使用
一、循环结构的4个要素
①初始化条件
②循环条件 ---->是boolean类型
③循环体
二、do-while循环的结构
①
do{
③;
④;
}while(②);
执行过程：①-③-④-②-③-④-...-②
说明：1.do-while至少会执行一次循环体
2.开发中，较多使用for和while
int num = 1;
do{
if(num % 2 != 0){
System.out.println(num);
}
num++;
}while(num <= 100);
}
16.for和while说明
1.不在循环条件部分限制次数的结构：for(;;)或while(true)
2.结束循环有集中方式？
方式一:循环条件部分返回false
方式二：在循环体中，执行break
Scanner input = new Scanner(System.in);
int count1 = 0,count2 = 0;
while(true){
int number = input.nextInt();
if(number > 0){
count1++;
}else if(number < 0){
count2++;
}else {
break;
}
}
System.out.println(count1);
System.out.println(count2);
17.break和continue
break和continue关键字的使用
使用范围
break： switch-case
循环结构中 结束当前循环
continue 循环结构中 结束当次循环
for(int i = 1;i < 10;i++){
if(i % 4 == 0){
// break;//123
continue;//12356789
}
System.out.println(i);
}
System.out.println("-------------");
laber:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环
//break laber;//结束指定标识的一层循环结构
System.out.println();
continue laber;//结束指定标示的一层循环结构档次循环
}
System.out.print(j);
18.数组
一、数组的概念
1.数组的理解：数组（Array），是多个相同类型数据按一定顺利排列的集合，并使用一个名字命名，
并通过编号的方式对这些数据进行同一管理。
2.数组的相关概念
数组名、元素、（角标、下标和索引）、（数组长度：元素的个数）
3.数组的特点：
1)数组是有序排列的
2)数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
3)创建数组对象会对内存中开辟一整块连续的空间
4)数组的长度一旦确定，就不能修改
4.数组的分类：
1)按照维度：一维数组、二维数组...
2)按照数组元素的类型：基本数据类型元素的数组、引用类型元素的数组
5.一维数组的使用
1)一维数组的声明和初始化
2)如何调用数组的指定位置的元素
3)如何获取数组的长度
4)如何遍历数组
5)数组元素的默认初始化值
>数组元素是整形：0
>数组元素是浮点型：0.0
>数组类型是char型：0或'u0000',而非'0'
>数组元素是boolean：false
>数组元素是引用数据类型：null
6)数组的内存解析
//一维数组的声明和初始化,静态初始化：数组的初始化和数组元素的赋值操作同时进行
int[] ids = new int[]{1001,1002,1003,1004};
//特殊
int[] arr = {1,2,3,5,8};
//动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
//数组一旦初始化完成，其长度就确定了。
//如何调用数组的指定位置的元素
names[0] = "张三";
names[1] = "李四";
names[2] = "王五";
names[3] = "六六";
names[4] = "唐七";
//如何获取数组的长度
int len = names.length;
System.out.println(len);
//如何遍历数组
for(int i = 0;i < names.length;i++){
System.out.print(names[i] + "t");
}
System.out.println();
//数组元素的默认初始化值
int[] array = new int[4];
for(int i = 0;i < 4;i++){
System.out.print(array[i] + "t");
}
}
19.多维数据
二维数组分为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等
二维数组的使用
1.理解
对于二维数组的理解，我们可以看成是一维数组array1有作为另一个一维数组array2的元素而存在。
其实，从数组底层的运行机制来看，其实没有多维数组。
2.二维数组的使用
1)二维数组的声明和初始化
2)如何调用数组的指定位置的元素
3)如何获取数组的长度
4)如何遍历数组
5)数组元素的默认初始化值
针对初始化方式一：比如：int[][] arr1 = new int[4][3];
外层元素的初始化值为：地址值
内存元素的初始化值为：与一维数组初始化情况相同
针对初始化方式二：比如：int[][] arr5 = new int[4][];
外层元素的初始化值为：null
内存元素的初始化值为：不能调用，否则报错
6)数组的内存解析
// 二维数组的声明和初始化
// 静态初始化
int[][] arr = new int[][] { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };
// 动态初始化1
String[][] arr2 = new String[3][2];
// 动态初始化2
String[][] arr3 = new String[3][];
//如何调用数组的指定位置的元素
System.out.println(arr[2][1]);
arr3[1] = new String[4];//arr3数组的第二行的创建空间为4
System.out.println(arr3[1][0]);
//如何获取数组的长度
System.out.println(arr.length);
System.out.println(arr[0].length);
//如何遍历数组
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j] + "t");
}
System.out.println();
}
//数组元素的默认初始化值
int[][] arr1 = new int[4][3];
System.out.println(arr1[0]);//地址值：[I@15db9742
System.out.println(arr1[0][0]);//null
int[][] arr5 = new int[4][];
System.out.println(arr5[0]);//null
//System.out.println(arr5[0][0]);//报错
}
java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
boolean equals(int[] a,int[] b):判断两个数组是否相等
String toString(int[] a):输出数组信息
void fill(int[] a,int val):将指定值填充到数组之中
void sort(int[] a):对数组进行排序
nt binarySearch(int[] a,int key):二分查找
1.数组中的常见异常：
数组角标越界异常：ArrayIndexOutOfBoundsException
空指针异常：NullPointerException
//1.数组角标越界异常：ArrayIndexOutOfBoundsException
int[] arr = new int[]{1,2,3,5,4,6,7,8};
for(int i = 0;i <= arr.length;i++){
System.out.println(arr[i]);
}
//空指针异常：NullPointerException
//情况一
int[] arr1 = new int[]{1,2,3};
arr1 = null;
System.out.println(arr1[0]);
//情况二
int[][] arr2 = new int[4][];
System.out.println(arr2[2][2]);
20.Java面向对象学习的三条主线
1.Java类及类的成员：属性、方法、构造器、代码块、内部类
2.面向对象三大特性：继承、封装性、多态、（抽象性）
3.其他关键字：this、super、static、final、abstract、interface、package、import等
二、“人把大象放进冰箱”
1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
①把冰箱打开
②抬起大象房价冰箱
③关闭冰箱
2.面向对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做
人{
打开(冰箱){
冰箱.开开();
}
抬起(大象){
大象.进入(冰箱);
}
关闭(冰箱){
冰箱.闭合();
} }
冰箱{
开开(){}
闭合(){}
}
大象{
进入(冰箱){
} }
三、面向对象的两个要素：
类：对一类事务的描述，是抽象的，概念上的定义
对象:是实际存在的该类事务的每个个体，因而也称为实力(instance)
>面向对象程序设计的重点是类的设计
>设计类，就是设计类的成员。
21.设计类，其实就是设计类的成员
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
场景类的对象 = 类的实例化 = 实例化类
二、类和对象的使用（面向对象思想落地的实现）
1.创建类。设计类的成员
2.创建类的对象
3.通过“对象.属性”或“对象.方法”调用对象的结构
三、如果创建了一个类的多个对象，每个对象都独立拥有一套类的属性。(非static)
意味着：如果我们修改一个对象的属性a。则不影响另一个对象属性a。
四、对象的内存解析
public class PersonTest {
public static void main(String[] args) {
//创建Person类的对象
Person p1 = new Person();
//调用对象的结构、属性和方法
//调用：属性：“对象.属性”
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//调用方法：“对象.方法”
p1.eat();
p1.sleep();
p1.talk("Chinese");
System.out.println("------------------------");
Person p2 = new Person();
System.out.println(p2.name);//null
System.out.println("------------------------");
//将p1变量保存的对象地址复制给p3，导致p1和p3指向了堆空间中的同一对象实体。
Person p3 = p1;
System.out.println(p3.name);//Tom
p3.age = 10;
System.out.println(p1.age);
}
}
class Person{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat(){
System.out.println("人可以吃");
}
public void sleep(){
System.out.println("人可以睡觉");
}
public void talk(String language){
System.out.println("人可以说话，使用" + language);
}
}
22.类中方法的声明和使用
方法：描述类应该具有的功能
比如：Math类：sqrt()random()...
Scanner类：nextXxx()...
Arrays类：sort()binarySearch()toString()equals()...
举例：
public void eat(){
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}
2.方法的声明：权限修饰符 返回值类型 方法名(形参列表){
注意：static、final、abstract来修饰的方法，后面再说
3.说明：
1)关于权限修饰符：
Java规定的四种权限修饰符：private、public、缺省、protected
2)返回值类型：有返回值 vs 没有返回值
如果方法有返回值，则必须在方法声明是，指定返回值的类型。同时，需要使用return关键字
来返回指定类型的变量或常量。
如果方法没有返回值，则方法声明是，使用void来表示。通常，没有返回值的方法中，就不使用
return，但是，如果使用的话，只能”return;“表示结束此方法。
我们定义方法该不该有返回值？
题目要求；凭经验，具体问题具体分析
3)方法名：属于标识符，遵循标识符的规则和规范，”见名知义“
4)形参列表：方法可以声明0个，1个，或多个形参
格式：数据类型1 形参1,数据类型2 形参2...
我们定义方法时，该不该定义形参？题目要求；凭经验：具体问题具体分析
5)方法体：方法功能的体现
4.return关键字的使用：
使用范围：使用再方法体中
作用：结束方法；针对有返回值类型的方法，使用“return 数据”方法返沪所要的数据
注意点：return关键字豁免不可以声明执行语句。
5.方法的使用中，可以调用当前类的属性或方法
特殊的：方法A又调用了方法A：递归方法。
方法中，不可以定义方法。
public class CustomerTest {
public static void main(String[] args) {
}
}
class Customer {
// 属性
String name;
int age;
boolean isMale;
// 方法
public void eat() {
System.out.println("客户吃饭");
}
public void sleep(int hour) {
System.out.println("休息了" + hour + "个小时");
}
public String getName() {
return name;
}
public String getNation(String nation) {
String info = "我的国籍是：" + nation;
return info;
}
}
23.类中属性的使用
属性（成员变量） vs 局部变量
1.相同点
1)定义变量的格式：数据类型 变量名 = 变量值
2)先声明，后使用
3)变量都有对应的作用域
2.不同点：
1）在类中声明的位置不同
属性：直接定义再类的一对{}内
局部变量：声明再方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2)关于权限修饰符的不同
属性：可以再声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected
目前，大家声明属性时，使用缺省的就行
局部变量：不可以使用权限修饰符
3)默认初始化值的情况：
属性：类的属性，根据其类型，都有默认初始化值。
整形(byte、short、int、long):0
浮点型(float、double):0.0
字符型(char):0(或'u0000')
布尔型(boolean):false
引用类型(类、数组、接口):null
局部变量：没有默认初始化值。
意味着：我们在调用局部变量之前，一定要显示复制。
特别地：形参调用时，我们赋值即可。
4)再内存中加载的位置
属性：加载到堆空间（非static）
局部变量：加载到栈空间
class User {
// 属性（或成员变量）
String name;
int age = 1;
boolean isMale;
public void talk(String language) {//language：形参，局部变量
System.out.println("人可以说话，使用" + language);
}
public void eat(){
String food = "烙饼";//局部变量
System.out.println("北方人喜欢吃" + food);
}
}
24.理解”万事万物皆对象”
1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构；
>Scanner,String等
>文件：File
>网络资源：URL
2.涉及到Java语言域前端的Html、后端的数据库交互式，前后端在Java层面交互时，都体现为类、对象。
二、内存解析说明
引用类型的变量，只肯存储两类之：null或地址值（含变量的类型）
三、匿名对象的使用
1.理解：我们创建的对象，没有显示的赋给一个变量名。即为匿名对象
2.特征：匿名对象只能调用一次
3.使用：如下
public class InstanceTest {
public static void main(String[] args) {
Phone phone = new Phone();
System.out.println(phone);
phone.senEmail();
phone.playGame();
//匿名对象
new Phone().senEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0
System.out.println("--------------");
PhoneMall mall = new PhoneMall();
mall.show(phone);
//匿名对象使用
mall.show(new Phone());
}
}
class PhoneMall{
public void show(Phone phone){
phone.senEmail();
phone.playGame();
}
}
class Phone{
double price;//价格
public void senEmail(){
System.out.println("发送邮件");
}
public void playGame(){
System.out.println("玩游戏");
}
public void showPrice(){
System.out.println(price);
}
}
25.可变个数形参的方法
1.jdk 5.0新增
2.具体使用
1)可变个数形参的格式：数据类型 ... 变量名
2)当调用可变个数形参的方法时，传入的参数个数可以时：0个，1个，2个...
3)可变个数形参的方法域本类中方法名相同，形参不同的方法之间构成重载
4)可变个数形参的方法域本类中方法名相同，形参类型相同的数组之间不构成重载，二者不共存
5)可变个数形参在方法的形参中，必须声明在末尾
6)可变个数形参在方法的形参中，最多只能声明一个可变形参
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
test.show("hello");
test.show("AA", "CC");
}
public void show(int i) {
}
public void show(String s) {
}
public void show(String... str) {
System.out.println("show(String ... str)");
}
// public void show(String[] str) {
// System.out.println("show(String ... str)");
// }
}
26.方法的重载（overload)loading...
1.定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
“两同一不同”：同一个类、相同方法名：参数列表不同：参数个数、类型不同
2.举例：Arrays类中重载sort / binarySearch()
3.判断是否重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。
4.在通过对象调用方法时，如何确定某一个指定的方法：方法名-->参数列表
public class OverLoadTest {
public static void main(String[] args) {
OverLoadTest test = new OverLoadTest();
test.getSum(1, "df");
}
public void getSum(int i, int j) {
System.out.println(i + j);
}
public void getSum(double d1, double d2) {
System.out.println(d1 + d2);
}
public void getSum(int i, String s) {
System.out.println(i + s);
}
}
27.关于变量的复制
如果变量是基本数据类型，此时赋值的变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值
方法的形参的传递机制：值传递
1.形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
2.值传递
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
public class ValueTransferTest {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ",n = " + n);
// 交换两个变量的值的操作
// int tem = m;
// m = n;
// n = tem;
ValueTransferTest test = new ValueTransferTest();
test.swap(m, n);//不能实现交换
System.out.println("m = " + m + ",n = " + n);
}
public void swap(int m,int n){
int tem = m;
m = n;
n = tem;
}
}
28.递归方法的使用
1.递归方法：一个方法体内调用它自身。
2.方法递归包含了一种隐士的循环，他会重复执行某段代码块，但这种重复执行无需循环控制。
递归一定要向已知方向递归，否则这种递归就变成了为穷递归，类似于死循环。
public class RecursionTest {
public static void main(String[] args) {
RecursionTest test = new RecursionTest();
System.out.println(test.getSum(100));
System.out.println(test.f(10));
}
// 1-100的和
public int getSum(int n) {
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
public int f(int n) {
if (n == 0) {
return 1;
} else if(n == 1){
return 4;
}else {
return 2 * f(n -1) + f(n - 2);
}
}
}
29.面向对象的特征值：封装与隐藏
一、问题引入
当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值。这里，
赋值操作要受到属性类型和数据存储范围制约。除此之外，没有其他制约条件。但是在实际问题中，我们往往需要个属性赋值加入额外的限制条件。这个条件就不能在属性声明是体现，我们只能通过方法进行限制条件的添加。（比如setLegs)。同时，我们需要避免用户在使用“对象.属性”的方式进行赋值。则需要将属性声明为私有的（private）。
>此时，针对于属性就体现了封装性。
二、封装性的体现
我们将类的属性私有化（private），同时，提供公共的（public）方法来获取（getXxx）和设置（setXxx）此属性的值
拓展：不对外暴露的私有的私有方法；单例模式
三、封装性的体现，需要权限修饰符来配合。
1.java 规定的4中权限（从小到大）：private(类内部)、缺省(类内部、同一个包)、protected(类内部、同一个包、不同包的子类)、public(同一工程)
2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
3.具体的：4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类修饰类的话，只能使用：缺省、public
总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
public class AnimalTest {
public static void main(String[] args) {
Annimal a = new Annimal();
a.name = "大黄";
a.age = 1;
// a.legs = 4;
a.shoe();
}
}
class Annimal {
String name;
int age;
private int legs;// 腿数
//对属性设置
public void setLegs(int l) {
if(l >= 0 && l % 2 == 0){
legs = 1;
}else {
legs = 0;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getLegs() {
return legs;
}
public void eat() {
System.out.println("动物进食");
}
public void shoe() {
System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
}
}
JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean，是指符合如下标准的Java类：
》类是公共的
》有一个无参的公共的构造器
》又属性，且有对应的个体、set方法
public class Customer {
private int id;
private String name;
public Customer() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
总结：属性赋值的先后顺序
1.默认初始化之；2.显示初始化；3.构造器初始化；4.通过”对象.方法“或”对象.属性“的方式，赋值；以上先后顺序：1-》2-》3-》4
类的结构之三：构造器（或构造方法、constructor)的使用
construct:建设、建造。construction:CCB constructor:建造者
一、构造器的作用
1.创建对象
2.初始化对象的信息
二、说明：
1.如果没有显示的定义的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式：权限修饰符 类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显示的定义了类的构造器之后，系统就不在提供默认的空参构造器
5.一个类中，至少有一个构造器
public class PersonTest {
public static void main(String[] args) {
Person person = new Person();
//创建类对象:new + 构造器
person.eat();
Person p1 = new Person("Tom");
}
}
class Person {
//属性
String name;
int age;
//构造器
public Person(){
System.out.println("Person().......");
}
public Person(String n){
name = n;
}
//方法
public void eat() {
System.out.println("人吃饭");
}
public void study() {
System.out.println("人可以学习");
}
}
30.package关键字的使用
1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在源文件的首行
3.每"."一次，就代表一层文件目录。
4.包，属于标识符，遵循标识符的命名规则、规范（xxxyyyyzzz)、”见名知义“
补充：同一个包下，不能命名同名的接口、类。不同的包下，可以命名同名的接口、类。
二、import关键字的使用
import：导入
1.在源文件中显式的使用import结构导入指定包下的接口、类
2.声明在包的声明和类的声明之间
3.如果需要导入多个结构，则并列写出即可
4.可以使用”xxx.*"的方式，表示可以导入xxx包下的所有结构
5.如果使用的类或接口是java.lang包下定义的，则可以省略import结构
6.如果使用的类或接口是本包下定义的，则可以省略import结构
7.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要一全类名的方式显示。
8.使用"xxx,*"方式表面可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需显示导入
9.import static:导入指定类或接口中的静态结构：属性或方法。
31.this关键字的使用
1.this可以用来修饰：属性、方法、构造器
2.this修饰属性和方法：this理解为：当前对象或当前正在创建的对象
1)在类的方法中，我们可以使用”this.属性”或“this.方法”的方式。调用当前对象属性或方法，但是，通常情况下，我们都选择省略“this."特殊情况下，如果方法的形参和类的属性名相同时，我们必须显式的使用”this.变量“的方式，表明此变量是属性，而非形参。
2)在类的构造器中，我们可以使用”this.属性”或“this.方法”的方式。调用当前对象属性或构造器，但是，通常情况下，我们都选择省略“this."特殊情况下，如果构造器的形参和类的属性名相同时，我们必须显式的使用”this.变量“的方式，表明此变量是属性，而非形参
3.this调用构造器
1)我们在类的构造器种，可以显式的使用”this(形参列表)“方式，调用本类种指定的其他构造器
2)构造器中不能通过”this(形参列表)“方式调用自己
3)如果一个类中有n个构造器，则最多有n - 1个构造器中使用了”this(形参列表)“
4)规定：”this(形参列表)“必须声明在当前构造器的首行
5)构造器内部，最多声明一个”this(形参列表)“，用来调用其他的构造器
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.setAge(1);
System.out.println(p1.getAge());
}
}
class Person {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void eat() {
System.out.println("人吃饭");
this.study();
}
public void study() {
System.out.println("人学习");
}
public Person() {
}
public Person(String name) {
this();//调用空参构造器
this.name = name;
}
}
32.快捷键
33.继承性 why？
一、继承性的好处：
1.减少了代码的冗余，提高了代码的复用性
2.便于功能的扩展
3.位置会多态性的使用，提供了前提
二、继承性的格式：class A extends B{}
A.子类、派生类、subclass
B.父类、超类、基类、supperclass
1. 体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有属性和方法。
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只是因为封装性的影响，使得子类不能直接调用父类的结构而已。
2.子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的拓展。
子类和父类的关系，不同于子集和集合的关系。
三、Java中关于继承性的规定：
1.一个类可以被多个子类继承
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。多层继承
4.子类直接继承的父类，称为直接父类；间接继承的父类称为间接父类
5.子类继承父类以后，就获取了直接父类以及所有简介父类中声明的属性和方法。
四、1.如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2.所有的java类（除java.lang.Object类之外）都直接或简介继承于java.lang.Object类
3.意味着，所有的Java类具有java.lang.Object类声明的功能。
//间接父类
public class Creature {
public void breath() {
System.out.println("呼吸");
}
}
//直接父类
public class Person extends Creature{
String name;
int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
//子类
public class Person extends Creature{
String name;
int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
//测试
public static void main(String[] args) {
Person p1 = new Person();
p1.age = 1;
p1.eat();
Stuent s1 = new Stuent();
s1.eat();
s1.sleep();
s1.name = "Tom";
s1.breath();
}
}
