JAVA核心编程

Java-核心编程笔记（第一周）
一、使用记事本编写运行Java程序
1.1、编写Java源程序（任何一个文本编辑器来编写）
a.Java源程序可以用一个空白记事本，然后如是输入以下内容
/*
第一个java源程序
/
public class HelloJava{
//这里是程序入口
public static void main(String args[]){
//输出字符串
Stytem.out.ptintln(“Hello Java”）;
}}
b.对原代码中的重要组成元素进行简单介绍
关键字：
public表示说明符，表明类的一个公共类，可以控制其他对象对类成员的访问
class用于表明一个类，其后所跟字符串是类的名称
static表示该方法的一个静态方法，允许调用main函数，无法创建类的实例
void表示main（）方法没有返回值
c.“/”"/“之间的内容和以”//"开始的内容为java的程序的注释
1.2、将写完代码后的文件另存为HelloJava.java,保存类型选择所有为文件
编译运行使用JDK中的javac的命令：
打开cmd，输入javac HelloWorld.java继续编译
运行编译.class文件，输入指令java Hello World
1.3、Java程序运行机制
编译型
解释型
程序运行机制
Java源文件(. java) ——>Java编译器——>字节码文件(. class)——>类装载器
字节码校检器──>解释器 ->操作系统(Windows、Linux等)
二、Java语法基础
2.1、Java标识符和关键字
标识符
Java中标识符是为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。
在Java语言中，标识符的构成规则如下。
标识符由数字（0_{9）和字母（A}Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字
符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）
注意：数字不能作为标识符的开始：如1ac
关键字：具有特殊含义的标识符例如：int、void、main…
用户自定义标识符：是由用户标识符生成的非保留字的标识符如：abc、name
2.2、命名规则
Java类的命名规则：
类名首字母大写，如果有多个单词组合，则每个单词首字母大写（大驼峰命名法）HelloWorld
小驼峰命名法:首个单词字母小型，后面的单词首字母大写
如：helloworld，Demo01
注意：java严格区分大小，如：name和Name表达意思不一样
2.3、javadoc文档注释
4.java变量的声明和初始化
java语言石墙类型（strongly Typed)语言，强类型
课堂实例：
*变量命名：
语法：变量类型 变量名字 赋值符号 值：
/
int age:// 声明变量，不赋值
age=32；// 声明变量之后赋值
String name=“大锤” //声明变量，赋值
//修改变量值（重新赋值）
age =56;
name =“张三”;
// int name;
// num="北京中关村“
// int 2num://非法命名
int n1,n2,n3,n4;//批量命名
n1 = 2;
n2 = 3;
n3 = 4;
n1= n2 = n3 = n4 = 56;
int num1 = 3,num2 =4;
/
* 变量的作用域：
* 全局变量：
* 定义在方法（函数）和代码块之外的变量
* 局部变量
* 定义在方法或者代码块之间的变量
*/
//定义全局变量
int age ;//全局变量
String name =“大锤”
//静态变量
static int number;
double price = 1399.99;
public static void main(String arsg[]){
//定义变量
int age;
if(true)

Java核心编程实验课笔记
一、Java常量
常量是指在程序的整个运行过程中值保持不变的量。
注意常量和常量值是不同的概念，常量值是常量的具体和直观的表现形式，
常量是形式化的表现。通常在程序中既可以直接使用常量值，也可以使用常量。
1、常量值

常量值又称为字面常量，它是通过数据直接表示的，因此有很多种数据类型，像整型和字符串型等。下面一一介绍这些常量值。
2、整型常量值
Java 的整型常量值主要有如下 3 种形式：
十进制数形式：**如 54、-67、0。
八进制数形式：**Java 中的八进制常数的表示以 0 开头，如 0125 表示十进制数： 85，-013 表示十进制数 -11。
十六进制数形式：Java中的十六进制常数的表示以0x或0X开头，如0x100表示十进制数256, -0x16 表示十进制数-22。
整型（int）常量默认在内存中占 32 位
长整型数，它在内存中占 64 位。
3、实型常量值
Java的实型常量值主要有如下两种形式。
十进制数形式:由数字和小数点组成，且必须有小数点，如12.34、-98.0。
科学记数法形式:如1.75e5或32&E3,中e或E之前必须有数字，且e或E之后的数字必须为整数。
Java实型常量默认在内存中占64位，是具有双精度型(double) 的值。
单精度型数值一般要在该常数后面加 F或f,如69.7f, 表示-个float型实数，它在内存中占32位。
4、布尔型常量值
Java的布尔型常量只有两个值，即false (假)和true (真)。
二、Java变量的作用域
变量的作用域规定了变量所能使用的范围，只有在作用域范围内才能被使用。根据变量的声明地点不同，变量的作用域也不同
变量又分为成员变量与局部变量
成员变量分为
（1）全局变量：无static修饰访问对象名变量名
（2）静态变量：用static修饰，访问类名变量名
局部变量分为
（1）方法参数变量：在整个方法内有下效
（2）方法局部变量：从定义这个变量开始到方法结束这一段时间内有效
（3）代码块局部变量：从定义这个变量开始到代码结束这一段时间内有效
局部变量在使用前必须被程序员主动初始化值
声明变量
首字符必须是字母、下划线、美元符号、人民币符号
标识符由数字大写字母小写字母下划线美元符号人民币符号以及所有在十六进制Oxco前的ASCLL码组成，不能吧关键字保留字作为标识符
三、Java中的数据类型：
基本数据类型包括 ：boolean（布尔型）、float（单精度浮点型）、char（字符型）、byte（字节型）、short（短整型）int（整型）、long（长整型）和 double （双精度浮点型）共 8 种
1.字节型：byte by = 127;
// System.out.println((byte) (by + 1));
2.短整型：short sh = 56;
3．整形： int num = 78946;
4.长整型
注意: 需要早长整型末尾添加L或者l：long number = 56L;
5.单精度浮点型
注意: 需要早长整型末尾添加F或者f;float fl = 3.14F
System.out.println(fl1);
6.双精度浮点型,java中小数默认是double类型;double db = 3.14159;
7.字符型
字符型的值使用单引号引起来，当值为整形时不需要单引号
char ch1 = 3;
char ch2 = ‘a’;
char ch3 = 97;
System.out.println(ch1);
System.out.println(ch3);
8.布尔值类型
注意：Java中布尔值类型只有true和false两个值
boolean bool1 = true;
boolean bool2 = false;
2、引用数据类型
除了基本数据类型，其他全部是引用数类型，如：String、数组等
（8.29）
一、数据类型转换
数据类型的转换是在所赋值的数值类型和被变量接收的数据类型不一致时发生的，它需要从一种数据类型转换成另一种数据类型。数据类型的转换可以分为隐式转换（自动类型转换）和显式转换（强制类型转换）两种。

1. 隐式转换（自动类型转换）：小类型数据转换为大类型数据
   满足条件：1、两种数据类型彼此兼容
   2、目标类型的取值范围大于源数据类型（低级类型数据 转换成高级类型数据
   3、在运算过程中，由于不同的数据类型会转换成同一种数据类型， 所以整型、浮点型以及字符型都可以参与混合运算。自动转换的规则是从低级类型数据转换成高级类型数据。转换规则如下：
   1、数值型数据的转换：byte→short→int→long→float→double。 2、字符型转换为整型：char→int。
   以上数据类型的转换遵循从左到右的转换顺序，最终转换成表达式中 表示范围最大的变量的数据类型。
   2、显示转换（强制类型转换）大类型数据转换为小类型数据需要强制转换
   语法:小类型变量名 = (需要转换的类型 (小类型)) 大类型;
   注意：大类型数据转换为小类型数据有可能会造成精度丢失和溢出
   short类型和char类型在转换时都需要强制转换
   String str1=“Hello”;
   int num1=(int)str1;//不能强转;
   String str1=(String)num1;//不能强转;
   注意：两种数据类型彼此兼容，否则不能互相转换
   基本数据类型不能与引用数据类型转换
   注意：char 类型比较特殊，char 自动转换成 int、long、float 和 double，但 byte 和 short 不能自动转换为 char，而且 char 也不能自动转换为 byte 或 short。
   注意：+号可以用作算术符号，也可以做字符串拼接//这样就可以相加。
   任何数据类型与字符串做+运算都会变为字符串

b1+num将数据类型统一之后在运算(往大类型数据统一)
Java运算符: 最基本的运算符包括算术运算符、赋值运算符、逻辑运算符和关系运算符等
代码实例
package com.zpark.day03;

public class Demo03 {
public static void main(String[] args) {
byte b1 = 12;
int num = 13;
byte b2;
// 将b1+num的结果赋值给b2
// b1 + num 将数据类型统一之后再运算（往大类型数据统一）
b2 = (byte) (b1 + num);
double d1 = 3.14159;
char ch1;
（8.30）
一、一元运算符
算术一元运算一共有 3 个，分别是 -、++ 和 –
a 是对 a 取反运算，a++ 或 a-- 是在表达式运算完后，再给 a 加一或减一。而 ++a 或 --a 是先给 a 加一或减一，然后再进行表达式运算。
二、二元运算符

•    | 加    | 求 a 加 b 的和，还可用于 String 类型，进行字符串连接操作 | a + b || -        | 减    | 求 a 减 b 的差                                           | a - b || *        | 乘    | 求 a 乘以 b 的积                                         | a * b || /        | 除    | 求 a 除以 b 的商                                         | a / b || %        | 取余  | 求 a 除以 b 的余数                                       | a % b |
  

二、Java 语言中算术运算符的功能是进行算术运算，
* 除了经常使用的加（+）、减（-）、乘（*）和除（\）外，
* 还有取模运算（％）。加（+）、减（-）、乘（*）、除（\）
* 和我们平常接触的数学运算具有相同的含义
三、 java中赋值运算符：
* =：赋值符号
* +=：如， num += 2; -----> 本质：num = num + 2;
* -=: 如， num -= 2; -----> 本质：num = num - 2;
* *=: 如， num *= 2; -----> 本质：num = num * 2;
* /=: 如， num /= 2; -----> 本质：num = num / 2;
* %=: 如， num %= 2; -----> 本质：num = num % 2;
四、java中逻辑运算符：
* 与、或、非
* &&（短路与）：如：a && b, 如果ab全部为true则结果为true，否则为false
* ||（短路或）：如：a || b, a或者b有一个为true，或者ab均为true，则为true，否则为false
* ！：a为true，则结果为false，a为false，则结果为true
*/
• 注意：&& 与 & 区别：如果 a 为 false，则不计算 b（因为不论 b 为何值，结果都为 false）
• || 与 | 区别：如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true）
注意：短路与（&&）和短路或（||）能够采用最优化的计算方式，从而提高效率。在实际编程时，应该优先考虑使用短路与和短路或。
结果为 boolean 型的变量或表达式可以通过逻辑运算符结合成为逻辑表达式。逻辑运算符 &&、|| 和 ！按表 2 进行逻辑运算。

课堂作业实例
package com.zpark.day05;

import java.util.Scanner;

public class Demo04 {
public static void main(String[] args) {
/**
* 1、定义String类型变量 name
* 2、定义int类型变量 age
* 3、定义double类型变量 height
* 4、定义boolean类型变量 flag
* 5、创建Scanner扫描器对象
* 6、提示用户输入用户的名字、年龄、身高、flag
* 7、获取用户输入的名字、年龄、身高、flag，并且给相应的变量赋值
* 8、将获取的数据打印到控制台
* 如：name = “张三”， age = 25， height = 199.5， flag = true
*/
String name;
int age;
double height;
boolean flag;

    // 创建扫描器对象
    Scanner scan = new Scanner(System.in);
    System.out.println("请输入您的名字：");
    name = scan.next();

    System.out.println("请输入您的年龄：");
    age = scan.nextInt();

    System.out.println("请输入您的身高：");
    height = scan.nextDouble();

    System.out.println("请输入状态：");
    flag = scan.nextBoolean();

    System.out.println("name = " + name + ", age = " + age +
            ", height = " + height + ", flag = " + flag);
}

}

（8.31）
一、.关系运算符
关系运算符（relational operators）也可以称为“比较运算符”，用于用来比较判断两个变量或常量的大小。关系运算符是二元运算符，运算结果是 boolean 型。当运算符对应的关系成立时，运算结果是 true，否则是 false。
注意点如下所示：
1、基本类型的变量、值不能和引用类型的变量、值使用 == 进行比较；boolean 类型的变量、值不能与其他任意类型的变量、值使用 == 进行比较；如果两个引用类型之间没有父子继承关系，那么它们的变量也不能使用 == 进行比较。
2、== 和 != 可以应用于基本数据类型和引用类型。当用于引用类型比较时，比较的是两个引用是否指向同一个对象，但当时实际开发过程多数情况下，只是比较对象的内容是否相当，不需要比较是否为同一个对象。
实例
public class Demo02 {
public static void main(String[] args) {
/**
* 当引用数据类型使用==和！=做比较运算时的区别：
*
/
String s1 = “Hello”;
String s2 = “Hello”;
String s3 = new String(“Hello”);
System.out.println(s1 == s2);
System.out.println(s1 == s3);
/*
* s1.equals(s3)：比较s1与s3的内容是否相同
*/
System.out.println(s1.equals(s3));

关系运算符的优先级为：>、<、>=、<= 具有相同的优先级，并且高于具有相同优先级的 !=、==。关系运算符的优先级高于赋值运算符而低于算术运算符，结合方向是自左向右。
3、equals(obj)方法和 == 的区别：
* equals方法比较的是两个对象的内容是否相等
* == 比较的是两个对象再内存中存放的地址是否为同一个
/
二、Scanner的基本使用
public class Demo03 {
public static void main(String[] args) {
/*
* java扫描器：用户从控制台输入数据，后台Java程序接收
*
*/
// 创建扫描器对象
Scanner scan = new Scanner(System.in);
//System.out.println(“请输入您的年龄：”);
// 使用scan.nextInt()方法获取用户输入的年龄（整数）
//int age = scan.nextInt();
//System.out.println(age);
// 获取用户输入的小数
// System.out.println(“请输入商品价格：”);
//System.out.println(scan.nextDouble());

    // 获取用户输入的字符串
    //System.out.println("请输入您的名字：");
    System.out.println("请您写一句诗：");
    // System.out.println(scan.next());
    System.out.println(scan.nextLine());
    /**
     * next()与nextLine()方法的区别：
     *      1、当遇到空格或者回车的时候 next()方法停止读取
     *      2、当遇到回车的时候 nextLine()方法停止读取，读取整行数据
     */
}

}
三、位运算符
位运算符主要用来对操作数二进制的位进行运算。按位运算表示按每个二进制位（bit）进行计算，其操作数和运算结果都是整型值。
1、 位逻辑运算符
位逻辑运算符包含 4 个：&（与）、|（或）、~（非）和 ^（异或）。除了 ~（即位取反）为单目运算符外，其余都为双目运算符。下表中列出了它们的基本用法。
运算符 含义 实例 结果
& 按位进行与运算（AND） 4 & 5 4
| 按位进行或运算（OR） 4 | 5 5
^ 按位进行异或运算（XOR） 4 ^ 5 1
~ 按位进行取反运算（NOT） ~ 4 -5
2、位与运算符
位与运算符为&，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位同时为 1，那么计算结果才为 1，否则为 0。因此，任何数与 0 进行按位与运算，其结果都为 0。
3、位或运算符

其运算规则是：参与运算的数字，低位对齐，高位不足的补零。如果对应的二进制位只要有一个为 1，那么结果就为 1；如果对应的二进制位都为 0，结果才为 0。
4、位异或运算符
位异或运算符为^，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位相同（同时为 0 或同时为 1）时，结果为 0；如果对应的二进制位不相同，结果则为 1。
位取反运算符
位取反运算符为~，其运算规则是：只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1。

（9.5）Java 流程控制语句
1、语句编写方式：在 Java 中，语句是最小的组成单位，每个语句必须使用分号作为结束符。
2、语句表达式：
在很多的高级语言中，有专门的赋值语句。而在 Java 中将赋值作为一个运算符，因此只有赋值表达式。在赋值表达式后面添加分号就成了独立的语句。
3、复合语句：复合语句又称为语句块，是很多个语句的组合，从而可以将多个语句看作单个语句。
一、if_else语句
选择结构（也叫分支结构）解决了顺序结构不能判断的缺点，可以根据一个条件判断执行哪些语句块。选择结构适合于带有逻辑或关系比较等条件判断的计算。例如，判断是否到下班时间，判断两个数的大小等。
if 语句是使用最多的条件分支结构，它属于选择语句，也可以称为条件语句。if 选择结构是根据条件判断之后再做处理的一种语法结构。默认情况下，if 语句控制着下方紧跟的一条语句的执行。不过，通过语句块，if 语句可以控制多个语句。if 语句的最简语法格式如下，表示“如果满足某种条件，就进行某种处理”。
课堂实例：
public class Demo01 {
public static void main(String[] args) {

    /**
     * 单分支结构：
     *     if () {
     *
     *     }
     */


    /**
     * 双分支结构
     * if语句：
     *      if (条件表达式) {
     *          // 条件为true执行
     *          // 代码块
     *      } else {
     *          // 条件为false执行
     *      }
     *
     *      案例：要求用户输入自己的年龄，然后判断其是否成年
     */
    // 创

if 语句的主要功能：是给程序提供一个分支。然而，有时候程序中仅仅多一个分支是远远不够的，甚至有时候程序的分支会很复杂，这就需要使用多分支的 if…else if 语句。
通常表现为“如果满足某种条件，就进行某种处理，否则如果满足另一种条件才执行另一种处理……，这些条件都不满足则执行最后一种条件”。if…else ifif (表达式) {
语句块1;
} else {
语句块2;
} 多分支语句的语法格式如下所示：
if(表达式1) {
语句块1;
} else if(表达式2) {
语句块2;
…
} else if(表达式n) {
语句块n;
} else {
语句块n+1;
}
课堂实例：
/**
单分支结构
if（）{
}
/
/
双分支结构
if语句：
If（条件表达式）{
//条件为true
//代码块
}else{
条件语句为false执行
}
/
多分支结构
if（）{
}else if (){
} else if(){
}…….{
/
f嵌套
* if(boolean){
* if(boolean){
* …
* }
* }else{
* if(boolean){
* …
* }
//最后的else语句可要可不要
案例：QQ登录功能，登录流程：1、用户输入用户名，2、用户输入密码，3、点击登录按钮
/
// 第一种情况：先判断用户名，然后判断密码
System.out.println("******************************");
System.out.println(“请输入您的用户名：”);
String username = scan.next();
System.out.println(“请输入您的密码：”);
String password = scan.next();
// 判断用户名是否正确
if (“2227894845”.equals(username)) {
// 用户名正确，判断密码是否正确
if (“123456”.equals(password)) {
// 密码正确
System.out.println(“恭喜你登成功”);
}else{
// 密码错误
System.out.println(“密码错误”);
}
}else{
// 用户名错误，结束登录
System.out.println(“用户名错误”);
}
// 第二种情况：直接同判断用户名和密码
}
}
三目运算符
Java 提供了一个特别的三元运算符（也叫三目运算符）。三元运算符的符号表示为“?:”，使用该运算符时需要有三个操作数，因此称其为三目运算符。使用条件运算符的一般语法结构为：result = ? : ;其中，expression 是一个布尔表达式。当 expression 为真时，执行 statement1， 否则就执行 statement3。此三元运算符要求返回一个结果，因此要实现简单的二分支程序，即可使用该条件运算符。
3.2、在使用条件运算符时，还应该注意优先级问题，在编译时会出现语法错误，因为条件运算符优先于赋值运算符。
四、switch case语句
switch 语句是 Java 的多路分支语句。它提供了一种基于一个表达式的值来使程序执行不同部分的简单方法。因此，它提供了一个比一系列 if-else-if 语句更好的选择。
switch(表达式) {
case 值1:
语句块1;
break;
case 值2:
语句块2;
break;
…
case 值n:
语句块n;
break;
default:
语句块n+1;
break;
}
其中，switch、case、default、break 都是 Java 的关键字。
Switch:表示“开关”，这个开关就是 switch 关键字后面小括号里的值，小括号里要放一个整型变量或字符型变量。表达式必须为 byte，short，int，char类型。Java7 增强了 switch 语句的功能，允许 switch 语句的控制表达式是 java.lang.String 类型的变量或表达式。只能是 java.lang.String 类型，不能是 StringBuffer 或 StringBuilder 这两种字符串的类型。
Case: 表示“情况，情形”，case 标签可以是：
1、类型为 char、byte、 short 或 int 的常量表达式。
2、枚举常量。
3、从 Java SE 7 开始， case 标签还可以是字符串字面量。
default: 表示“默认”，即其他情况都不满足。default 后要紧跟冒号，default 块和 case 块的先后顺序可以变动，不会影响程序执行结果。通常，default 块放在末尾，也可以省略不写。
**注意：**重复的 case 值是不允许的。
break：表示“停止”，即跳出当前结构。
如果在 case 分支语句的末尾没有 break 语句，有可能触发多个 case 分支。那么就会接着执行下一个 case 分支语句。这种情况相当危险，常常会引发错误。为此，我们在程序中从不使用 switch 语句。
switch 语句的执行过程如下：表达式的值与每个 case 语句中的常量作比较。如果发现了一个与之相匹配的，则执行该 case 语句后的代码。如果没有一个 case 常量与表达式的值相匹配，则执行 default 语句。当然，default 语句是可选的。如果没有相匹配的 case 语句，也没有 default 语句，则什么也不执行。

（9.6）
一、嵌套语句（switch）
可以将一个 switch 语句作为一个外部 switch 语句的语句序列的一部分，这称为嵌套 switch 语句。因为一个 switch 语句定义了自己的块，外部 switch 语句和内部 switch 语句的 case 常量不会产生冲突。例如，下面的程序段是完全正确的：
switch特点：
1、switch 语句不同于 if 语句的是 switch 语句仅能测试相等的情况，而 if 语句可计算任何类型的布尔表达式。也就是 switch 语 句只能寻找 case 常量间某个值与表达式的值相匹配。
2、在同一个 switch 语句中没有两个相同的 case 常量。当然，外部 switch 语句中的 case 常量可以和内部 switch 语句中的 case 常量相同。
3、switch 语句通常比一系列嵌套 if 语句更有效。
二、If语句何switch语句的区别

1. 从使用效率上区分

    从使用效率上区分，在对同一个变量的不同值作条件判断时，既可以使用 switch 语句，也可以使用 if 语句。使用 switch 语句的效率更高一些，尤其是判断的分支越多，越明显。
   

2. 从实用性上区分

    从语句的实用性角度区分，switch 语句不如 if 条件语句，if 语句是应用最广泛和最实用的语句。
   

3. 何时使用 if 语句和 switch 语句

    在程序开发的过程中，何时使用 if 语句和 switch 语句，需要根据实际情况而定，应尽量做到物尽其用。不能因为 switch 语句的效率高就一直使用，也不能因为 if 语句常用就不用 switch 语句。需要根据实际情况，具体问题具体分析，使用最适合的条件语句。
    一般情况下，对于判断条件较少的，可以使用 if 条件语句，但是在实现一些多条件的判断中，最好使用 switch 语句。
   

三、while和do while循环
3.1、While语法：
while循环：
* 语法：
* while (循环条件) {
* 循环体
* }
do while:
* 语法：
* do{
* 循环体
* } while (循环条件);
3.2
区别： /**
* while循环与do…while循环的区别：
* 1、while是先判断后执行，do…while循环是先执行然后再判断
* 2、do…while循环至少执行一次
* while循环与do…while的特点：都是循环执行某一语句，循环次数素不固定
3.3课堂实例
public class Demo01 {
public static void main(String[] args) {
/**
* while循环：
* 语法：
* while (循环条件) {
* 循环体
* }
*
* 案例：计算1+到100的和
* 1+2+3+4+5+6+7+…+100
*/
int num = 1;
int sum = 0;

    while (num <= 100) {

// sum = sum + num;
sum += num;

        num ++;
    }
    System.out.println(sum);


    /**
     * do.while循环
     *      语法：
     *          do{
     *              循环体
     *          } while (循环条件);
     *      案例：计算1+到100的和
     *         1+2+3+4+5+6+7+....+100
     */

    int num2 = 1;
    int sum2 = 0;

    do {
        sum2 += num2;
        num2 ++;
    } while (num2 <= 100);
    System.out.println(sum2);

    /**
     * 输出如下图形
     *             *
     *             **
     *             ***
     *             ****
     *             *****
     */
    // 记录输出的次数
    int num3 = 1;

    while (num3 <= 5) {
        if(num3 == 1){
            System.out.println("*");
        }
        if(num3 == 2){
            System.out.println("**");
        }
        if(num3 == 3){
            System.out.println("***");
        }
        if(num3 == 4){
            System.out.println("****");
        }
        if(num3 == 5){
            System.out.println("*****");
        }

        num3 ++;

    }

    /**
     * while循环与do...while循环的区别：
     *      1、while是先判断后执行，do...while循环是先执行然后再判断
     *      2、do...while循环至少执行一次
     * while循环与do...while的特点：都是循环执行某一语句，循环次数素不固定
     */

}

}

（9.7）
一、for循环嵌套
1.1、嵌套循环既可以是 for循环嵌套 while 循环，也可以是 while 循环嵌套 do-while 循环 …… 即各种类型的循环都可以作为外层循环，也可以作为内层循环。
当程序遇到嵌套循环时，如果外层循环的循环条件允许，则开始执行外层循环的循环体，而内层循环将被外层循环的循环体来执行——只是内层循环需要反复执行自己的循环体而已。
当内层循环执行结束，且外层循环的循环体执行结束时，则再次计算外层循环的循环条件，决定是否再次开始执行外层循环的循环体。
二、foreach 语句的用法
foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。
一和二课堂实例：
public class Demo01 {
public static void main(String[] args) {
// 定义int类型的数组
int[] arr = {12, 56, 78, 99, 13, 45, 48};
// 访问数组元素：通过数组下标访问元素：如：arr[i]则表示访问数组 arr下标为i的元素
System.out.println(arr[2]);
// 遍历数组元素：将数组元素进行逐一的访问, arr.length获取数组的长度
for (int index = 0; index < arr.length; index ++) {
System.out.println(arr[index]);
}

    /**
     * foreach语法:
     *      for(迭代变量类型 变量的名字 ：需要遍历（迭代）的对象){
     *          语句块；
     *      }
     */
    int[] array = {12, 56, 78, 99, 13, 45, 48};
    for(int num : array){
        System.out.print(num + ", ");
    }
    
}

}
三、break 语句
3.1、某些时候需要在某种条件出现时强行终止循环，而不是等到循环条件为 false 时才退出循环。此时，可以使用 break 来完成这个功能。break 用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到 break，系统将完全结束该循环，开始执行循环之后的代码。
3.2、在 Java 中，break 语句有 3 种作用，分别是：在 switch 语句中终止一个语句序列、使用 break 语句直接强行退出循环和使用 break 语句实现 goto 的功能
3.3、使用 break 语句直接强行退出循环
可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。

3.4、break 语句
某些时候需要在某种条件出现时强行终止循环，而不是等到循环条件为 false 时才退出循环。此时，可以使用 break 来完成这个功能。break 用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到 break，系统将完全结束该循环，开始执行循环之后的代码。
在 Java 中，break 语句有 3 种作用，分别是：在 switch 语句中终止一个语句序列、使用 break 语句直接强行退出循环和使用 break 语句实现 goto 的功能
1、使用 break 语句直接强行退出循环（break 不带标签）
可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。
方法的调用：
调用方法：对象名.方法名(实参列表)，类名.方法名()。
Java支持两种调用方法的方式，根据方法是否有返回值来选择：
（1）当方法有返回值时，方法调用通常被当作一个值，例如：
int num = max(30, 40);
（2）如果方法返回值类型是void时，方法调用一定是一条语句，例如：
System.out.println(“Hello World”);
System.out.println( message() );
方法重载：
重载就是在一个类中，有相同的函数名称，但参数列表不相同的方法。
方法重载的规则：
方法名字必须相同
参数列表必须不同（参数个数不同、类型不同、参数排列顺序不同等）
方法的返回值可以相同，也可以不同（方法的重载与返回值类型无关）。
仅仅只是返回类型不同的话，则不足以称为方法的重载。
方法签名：
方法名+参数列表
重载方法调用规则：
编译器在编译时会根据方法的签名自动绑定调用的方法

算法案例：
package com.zpark.day08;

import java.util.Scanner;

/**

• @PackageName: com.zpark.day08

• @ClassName: Demo04

• @Description:

• @author: RZS

• @date: 2022/9/7 9:24
  /
  public class Demo04 {
  /*

  • 方法（函数）的类型：

  •  1、无参无返回值
    

  •      修饰符  void  方法名(){ 方法体 }
    

  •  2、无参有返回值
    

  •      修饰符   返回值类型   方法名(){ 方法体}
    

  •  3、有参无返回值
    

  •      修饰符   void   方法名(参数1， 参数2,....){ 方法体}
    

  •  4、有参有返回值
    

  •      修饰符   返回值类型  方法名(参数1， 参数2,....){ 方法体}
    

  */

  /**

  • 比较两个数的大小，将大的值返回回去

  • @param num1

  • @param num2

  • @return 返回最大值
    */
    public int max(int num1, int num2){
    /int max = num2;
    if (num1 > num2) {
    max = num1;
    }
    return max;/

    return num1 >= num2 ? num1 : num2;
    }

  /**

  • 定义方法：
  • 功能：

  •  比较两个数大小，返回布尔值
    

  */
  public boolean isMax(int n1, int n2){
  return n1 > n2 ? true : false;
  }

  /**

  • 定义方法：
  • 要求：

  •  计算用户输入i的阶层
    

  */
  public static long stratum(long num){
  long result = 1;
  // 判断num是否为0和1
  if (num == 0 || num == 1) {
  return result;
  }
  // num不为0和1
  for (long i = 2; i <= num; i++) {
  result *= i;
  }
  return result;
  }

  /**

  • 定义判断成绩优良中差等级的方法
    */
    public final static String grade(int score){
    String message = null;

    if (score < 0 || score > 100) {
    return “成绩有误”;
    }

    if (score < 60) {
    message = “D”;
    }else if(score >= 60 && score < 75){
    message = “C”;
    }else if(score >= 75 && score < 85){
    message = “B”;
    }else {
    message = “A”;
    }
    return message;
    }

  /**

  • 方法调用

  •  1、通过 对象.方法名字（参数）
    

  •  2、类名.方法（参数）
    

  •  3、方法（参数）
    

  */
  public static void main(String[] args) {
  // 创建对象
  Demo04 d4 = new Demo04();
  // 调用非static关键字修饰的方法，语法：对象.方法(参数)
  int max = d4.max(3, 5);
  System.out.println(max);
  boolean b = d4.isMax(56, 78);
  System.out.println(b);

   // 调用被static修饰的方法，语法：类名.方法(参数)
   String grade = Demo04.grade(56);
   System.out.println(grade);
   long stratum = Demo04.stratum(10);
   System.out.println(stratum);
  
   long stratum1 = stratum(10);
   System.out.println(stratum1);
  

// int max1 = max(1, 3);
}

}

package com.zpark.day08;

/**

• @PackageName: com.zpark.day08

• @ClassName: Demo05

• @Description:

• @author: RZS

• @date: 2022/9/7 16:33
  */
  public class Demo05 {
  public static void main(String[] args) {
  // 创建demo05对象
  Demo05 d5 = new Demo05();
  d5.fun1();
  d5.fun1(56);
  d5.fun1(3.141598);
  d5.fun1(12, 56);
  }

  /*
  方法重载：
  重载就是在一个类中，有相同的函数名称，但参数列表不相同的方法。

   注意：
       方法重载只与方法名字和参数列表有关，与方法返回值类型无关
  
   方法签名：方法名字 + 参数列表
  
   什么是程序？
   答：程序 = 算法 + 数据结构
  

  */

  public void fun1(){
  System.out.println(“我是无参无返回值的方法”);
  }

  public int fun1(int num){
  System.out.println(“有参无返回值的方法参数 int num”);
  return 0;
  }

  public void fun1(double d){
  System.out.println(“有参无返回值的方法参数 double d”);
  }

  public String fun1(int number, int num){
  System.out.println(“有参无返回值的方法参数 int number, int num”);
  return null;
  }

}
递归算法
是一种直接或者间接地调用自身的算法。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
**递归算法：**在函数或子过程的内部，直接或者间接地调用自己的算法。
**递归算法的实质：**是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数(或过程)来表示问题的解。
递归算法解决问题的特点：
　(1) 递归就是在过程或函数里调用自身。
　(2) 在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口。
　(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
　(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。
递归的两个条件：
1、可以通过递归调用来缩小问题规模，且新问题与原问题有着相同的形式。（自身调用）
2、存在一种简单情境，可以使递归在简单情境下退出。（递归出口）
**递归三要素：
1、一定有一种可以退出程序的情况；
2、总是在尝试将一个问题化简到更小的规模
3、父问题与子问题不能有重叠的部分
package com.zpark.day08;

/**

• @PackageName: com.zpark.day08

• @ClassName: Demo07

• @Description:

• @author: RZS

• @date: 2022/9/7 17:19
  /
  public class Demo07 {
  /*

  • 设计一个方法：

  •  使用递归计算i的阶层
    

  */
  long result = 1;
  public long stratum(long num){

   // 递归出口，当num = 0 or 1的时候，结束方法
   if (num == 0 || num == 1) {
       return result;
   }
  
   // result = result * stratum(num--);
   result *= num;
   num --;
   return stratum(num);
  

  }

  public static void main(String[] args) {
  Demo07 d7 = new Demo07();
  long stratum = d7.stratum(4);
  System.out.println(stratum);
  }
  }

（9.9）
一、数组
数组的定义：
相同数据类型元素的集合、是一种数据类型(引用类型)
数组的声明：
首先必须先声明数组变量，然后才能在程序中使用数组，数组的定义方式有如下几种：

int[ ] arr; 
	或者  
int arr[ ];
``
		使用new关键字来声明数组：例如，
​```java
int[ ] arr = new int[ 数组长度 ];

数组元素赋值：

arr[i] = 10;

访问数组：
数组的访问是通过数组的下标来进行访问的，数组下标（索引）从0开始
获取数组的长度：

arr.length

数组的四个基本特点：
1、 数组一旦被创建，它的大小将不可以在被改变。
2、 数组元素必须是相同类型的，不允许出现混合类型。
3、 数组中的元素可以是任何类型，包括基本类型与引用类型。
4、 数组属于引用类型，数组可以看成是一个对象，数组中的每一个元素相当于该对象的成员变量，因为数组本身就是对象，Java中对象是存放在堆中的，因此数组无论保存原始类型还是其他类型，数组对象本身都是在堆中。
数组的下标合法区间为：[0，length-1]，如果在这个范围之外将会报错，这种情况称为数组下标越界。例如：

public static void main(String args[]){
       int[]  arr  =  new  int[2];
// 下列代码将在运行时出现ArrayIndexOutOfBoundsException异常
       System.out.ptintln(arr[2]);
}

注意：
1、 数组是相同数据类型（数据类型可以为任意类型）的有序集合。
2、 数组也是对象，数组元素相当于对象的成员变量。
3、 数组一旦声明，长度就已经确定，不可以再被改变，如果越界，则会报：ArrayIndexOutOfBoundsException异常
算法案例：
package com.zpark.day09;

import java.util.Date;

public class Demo01 {
public static void main(String[] args) {
/**
* 数组定义：
* 用来存放相同类型的一组数据
* 数组下标从0开始，对数组元素进行操作是通过数组的下标（索引）
* 数组一旦被创建，则数组的长度不可被修改
* 语法：
* 静态创建数组
* 数据类型[] 数组名 = {值1，值2…}
* 数据类型 数组名[] = {值1，值2…}
* 动态创建数组
* 数据类型[] 数组名 = new 数据类型[数组长度]
* 数据类型 数组名[] = new 数据类型[数组长度]
*/
// 静态创建数组，特点：创建数组的同时给数组元素赋值
int arr[] = {1, 2, 4, 8, 9};
// 动态创建数组，特点创建数组时指定数组的长度
long[] arr1 = new long[5];

    int arr2[] = new int[]{1, 5, 8, 9};

    // 数组元素赋值：语法，数组名[索引] = 值
    double dArr[] = new double[3];
    // 给数组的第一个元素赋值
    dArr[0] = 3.14159;
    // 给数组的第二个元素赋值
    dArr[1] = 0.618;

    // 使用数组元素
    System.out.println(dArr[0] + 2);// 打印数组的第一个元素

    // 数组元素必须是相同类型的，不允许出现混合类型。
    // dArr[2] = "hello array"; 数组元素类型与数组类型不匹配，语法报错


    // 定义引用数据类型数组
    String[] str = new String[5];
    // 创建demo01对象数组
    Demo01[] d1 = new Demo01[10];
    Date date[] = new Date[3];

    // 数组的长度获取方式，array.length


    // 获取数组d1的长度
    int len = d1.length;
    System.out.println("数组demo01的长度为：" + len);
}

}

第四周
二维数组：
数据类型[][] 数组名字 = new 数据类型[m][n]
本质：数组的元素还是数组
访问二维数组的元素，语法：arr[x][y]
arr[0][0] = 10;
arr[0][1] = 20;
arr[0][2] = 30;

    arr[1][0] = 22;
    arr[1][1] = 32;
    arr[1][2] = 42;

数组的复制：
System.arraycopy(arr, start, dist, index, length)
数组扩容与缩容的实质：
就是创建一个新的数组，新数组的长度比原来的数组（大，扩容，小，缩容）
OOP：
所谓的OOP就是指的面向对象编程.这是一种计算机编程架构.OOP的一条基本准则是计算机程序是由单个能够引
起子程序作用的单元或对象组合而成.OOP达到了软件工程的三个主要目标:重用性,灵活性和扩展性.为了实现
整体运算,每个对象都能够接收消息,处理数据和向其它对象发送消息.OOP主要有以下的概念和组件.
组件: 数据和功能一起在运行着的计算机程序中形成的单元,组件在OOP计算机称重是模块和结构化的基础.
抽象性: 程序有能力忽略正在处理中信息的某些方面,即对信息主要方面关注的能力
封装: 也叫作信息封装:确保组件不会以不可预期的方式改变其它组件内部状态;只有在那些提供了内部状态改变方法的
组建中,才可以访问其内部状态.每类组件都提供了一个与其它组件联系的接口.并规定了其它组件进行调用的方法.
多态性: 组件的引用和类集会涉及到其它许多不同类型的组件,而且引用组件所产生的的结果得依据实际调用的类型.
继承性: 允许在现存的组件基础上创建子类组件,着统一并强调了多态性和封装性.典型的来说就是用类来对组件进行分
组,而且还可以定义新类为现存的类的扩展,这样就可以将类组织成树形或网状结构,这体现了动作的通用性.
由于抽象性/封装性/重用性以及便于使用等方面的原因,以组件为基础的编程在脚本语言中已经变得特别
流行.Python 和 Ruby 是最近才出现的语言，在开发时完全采用了 OOP 的思想，而流行的 Perl 脚本
语言从版本5开始也慢慢地加入了新的面向对象的功能组件。用组件代替“现实”上的实体成为 JavaScript（ECMAScript）
得以流行的原因，有论证表明对组件进行适当的组合就可以在英特网上代替 HTML 和 XML 的文档对象模型（DOM）。

Java内存分析
堆: new出来的对象(包括实例变量)
栈:局部变量(包括方法的参数)
方法区: .class字节码文件(包括方法、静态变量)

内存区域类型：
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制；
2. 堆：存放所有new出来的对象；
3. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中(对象可能在常量池里)（字符串常量对象存放在常量池中。）；
4. 静态域：存放静态成员（static定义的）；
5. 常量池：存放字符串常量和基本类型常量（public static final）。有时，在嵌入式系统中，常量本身会和其他部分分割离开(由于版权等其他原因)，所以在这种情况下，可以选择将其放在ROM中 ；
6. 非RAM存储：硬盘等永久存储空间

对于string的特殊解释
对于字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。
对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。
这也就是有道面试题：String s = new String(“xyz”);产生几个对象？答：一个或两个，如果常量池中原来没有”xyz”,就是两个。
例如：

1. 堆:
   1.1) 存储new出来的对象(包括实例变量)
   1.2) 垃圾: 没有任何引用所指向的对象
   垃圾回收器(GC)**不定时到内存中清理垃圾，
   回收过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，
   调用System.gc()可以建议虚拟机尽快调度GC来回收
   1.3) 内存泄漏: 不再使用的内存没有被及时的回收
   建议: 对象不再使用时及时将引用设置为null
   1.4) 实例变量的生命周期:
   在创建对象时存储在堆中，对象被回收时一并被回收
2. 栈:
   2.1) 存储正在调用的方法中的所有局部变量(包括方法的参数)
   2.2) 调用方法时，会在栈中为该方法分配一块对应的栈帧，
   栈帧中存储方法中的局部变量(包括参数)，
   方法调用结束时，栈帧被清除，局部变量一并被清除
   2.3) 局部变量的生命周期:
   方法被调用时存储在栈中，方法结束时与栈帧一并被清除
3. 方法区:
   3.1) 存储.class字节码文件(包括静态变量、方法)
   3.2) 方法只有一份，通过this来区分具体的调用对象

对象数组
数组是对象：
1、在Java中，数组属于引用数据类型。
2、数组对象存储在堆中，数组变量属于引用类型，存储数组对象的地址信息，指向数组对象。
数组的元素可以看成数组对象的成员变量（只不过类型全部相同）
public class Demo02 {
public static void main(String[] args) {
// 定义一个数据类型，用于存放Student信息
Student[] stu = new Student[48];
// 创建student对象
Student zs = new Student(“张三”, 23, “202110107890”);
// 把张三对象装到数组中
stu[0] = zs;

    stu[1] = new Student("李四", 21, "202145678956");

    Demo01 d1 = new Demo01();

// stu[2] = d1; 报错，数据类型不匹配

    System.out.println(stu[0]);

    // 案例：定义一个数组，可以存放任意数据类型
    Object[] obj = new Object[3];
    obj[0] = 12;
    obj[1] = stu;
    obj[2] = "hello";

    Student[] students = {new Student(), new Student(), new Student()};

访问控制修饰符
private修饰的成员变量和方法仅仅只能在本类中访问调用。

public修饰的成员变量和方法可以在任何地方调用，public修饰的内容是对外提供可以被调用的功能，需要相对稳定，private修饰的内容是对类实现的封装，如果“公开”会增加维护的成本。
protected和默认访问控制
1）用protected修饰的成员变量和方法可以被子类及同一个包中的类使用。
2）默认的访问控制即不书写任何访问修饰符，默认访问控制的成员变量和方法可以被同一个包中的类调用
package com.zpark.oop.day03;

public class Demo04 {
/**
* private：私有的
* 特点：凡是被private关键字修饰的属性和方法，只能在本类了当中访问，在其他类当中访问则没有权限
*
* public：关键字
* 特点：任何地方都可以访问
*/

public String nickname; // 昵称

private String name; // 姓名

protected int age;

double salary; // 当不添加任何修饰符时，则为默认访问修饰符default


public void a(){
    System.out.println("这是公共的方法");
}

private void b(){
    System.out.println("这是私有的方法");
}

public static void main(String[] args) {
    // 创建Demo04对象
    Demo04 d4 = new Demo04();
    // 访问d4对象的公有属性和方法
    d4.nickname = "大锤";
    System.out.println(d4.nickname);

    d4.a();

    // 访问d4对象的私有属性和方法
    d4.name = "张无忌";
    System.out.println(d4.name);
    d4.b();
}

}

public class Demo05 {
public static void main(String[] args) {
// 创建Demo04对象
Demo04 d4 = new Demo04();
// 访问d4对象的公有属性和方法
d4.nickname = “大锤”;
System.out.println(d4.nickname);

    d4.a();

    // 访问d4对象的私有属性和方法
    // d4.name = "张无忌"; 不能访问其他类中的私有属性
    // System.out.println(d4.name);
    // d4.b(); 不能访问其他类中的私有方法

    // 访问默认修饰符的属性
    d4.age = 23;
    // 访问默认修饰符的属性
    d4.salary = 5000.0;

    // 访问默认修饰符修饰的类
    A a = new A();
    System.out.println(a.name);

}

}

package com.zpark.oop.day03;

public class Student {
String name; // 姓名
int age; // 年龄
String number; // 学号

public Student(){
    // 无参构造器
}

public Student(String name, int age, String number) {
    this.name = name;
    this.age = age;
    this.number = number;
}

@Override
public String toString() {
    return "Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", number='" + number + '\'' +
            '}';
}

}

封装
封装，简单的说就是该露的露，该藏的藏。我们在设计程序是要追求“高内聚，低耦合”，其中，高内聚指的是类的内部数据操作细节由自己完成，不允许外部干涉。低耦合指的是仅暴露少量的方法给外部调用（使用get/set方法）。
封装（对数据的隐藏），通常来说，应禁止直接访问应该对象中数据的实际表示，而是应该通过操作接口来访问，这种称为信息隐藏。
封装的意义：
1、对外提供可调用的，稳定的功能。
2、封装容易变化的，具体的细节，外界不可访问，这样封装的意义在于：
a. 降低代码出错的可能性，便于维护。
b. 当内部的实现细节改变时，只要保证对外的功能定义不变，其他的模块就不会因此而受到牵连。
封装的核心：属性私有化，行为（方法）公开化

继承

1、通过extends关键字可以实现类的继承。
2、子类可以继承父类的成员变量及成员方法，同时也可以定义自己的成员变量和成员方法。
3、Java语言不支持多重继承，一个类只能继承一个父类，但是一个父类可以有多个子类。
1、子类的构造方法中必须通过super关键字调用父类的构造方法，这样可以妥善的初始化继承自父类的成员变量。
2、如果子类的构造方法中没有调用父类的构造方法，Java编译器会自动的加入对父类的无参构造方法的调用（如果父类没有无参构造方法，则会有编译错误）。

多态
多态指的是同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多。
多态存在的条件：
1、 有继承关系
2、 子类重写父类的方法
3、 父类引用指向子类对象
多态的意义:
1、行为的多态(所有抽象方法都是多态的)
2、对象的多态(所有对象都是多态的)
多态的表现形式:
1、重写:根据对象的不同来表现多态
2、重载:根据参数的不同来表现多态
注意：多态是方法的多态性，不是属性的多态性

super关键字
在java里面，对于super关键字通常有两种用法：**

1. 用在子类的构造方法里（初始化用），主要是调用父类的默认构造方法，如果父类有不止一个构造方法，可以通过super指定具体的构造函数，比如 super(paras)。
2. 用在子类里调用隐藏或重写的属性或行为，比如 super.onDestroy()等等。
   对于第1种需要注意，super表示当前类的父类对象，super()调用的是父类默认的构造方法，即这样可以对父类进行初始化。如果没有对父类进行初始化，当子类调用父类的方法时，便会从逻辑上出现错误，因为没对父类初始化，父类的方法和属性便没有内存空间。

关于super 与 this 关键字的对比（区别）：**

1. super（参数）：调用基类中的某一个构造函数（应该位于子类构造函数中的第一条语句）。
2. this（参数）：调用本类中的构造函数（应该位于构造函数中的第一条语句）。
3. super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）。
4. this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）
   5、调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
   6、super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它构造方法。
   7、super()和this()均需放在构造方法内第一行。
   8、尽管可以用this调用一个构造器，但却不能调用两个。
   9、this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
   10、 this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
   11、 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

方法重写
方法的重写(Override):
1、发生在父子类中，方法名称相同，参数列表相同，方法体不同
2、重写方法被调用时，看对象的类型
3、遵循"两同两小一大"原则:------------了解
3.1、两同:
3.1.1、方法名称相同
3.1.2、参数列表相同
3.2、两小:
3.2.1、派生类方法的返回值类型小于或等于超类方法的
a、void时，必须相同
b、基本数据类型时，必须相同
c、引用数据类型时，小于或等于
3.2.2、派生类方法抛出的异常小于或等于超类方法的
3.3、一大:
3.3.1、派生类方法的访问权限大于或等于超类方法的
重写与重载的区别:
1、重写(Override):
1.1、发生在父子类中，方法名相同，参数列表相同，方法体不同
1.2、“运行期绑定”，看对象的类型绑定方法
2、重载(Overload):
2.1、发生在一个类中，方法名相同，参数列表不同，方法体不同
2.2、“编译期绑定”，看参数/引用的类型绑定方法
补充：
编译期:.java源文件，经过编译，生成.class字节码文件
运行期:JVM加载.class并运行.class
编译错误:只是检查语法
十一、多态
多态指的是同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多。
多态存在的条件：
1、 有继承关系
2、 子类重写父类的方法
3、 父类引用指向子类对象
多态的意义:
1、行为的多态(所有抽象方法都是多态的)
2、对象的多态(所有对象都是多态的)
多态的表现形式:
1、重写:根据对象的不同来表现多态
2、重载:根据参数的不同来表现多态

注：多态是方法的多态性，属性没有多态性。

十二、instanceof 和类型转换
instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例（实例指的是“类”在实例化之后叫做一个“实例”。实例化：通常把用类创建对象的过程称为实例化），返回 boolean 的数据类型。
向上造型：
1)超类型的引用指向派生类的对象
2)能点出来什么，看引用的类型
向下造型：（容易出现类型转换异常）
1)派生类的引用指向超类对象
2)向下造型需要进行强转
3)能点出来什么，看引用的类型
第六周笔记
十三、static和final关键字
1、static修饰成员变量
1、用static修饰的成员变量不属于对象的数据结构，属于类的数据结构。
2、static变量是属于类的变量，通常可以通过类名来引用static成员。
3、static成员变量和类的信息一起存储在方法区，而不是在堆中，一个类的static变量只有一份，无论这个类创建了多少个对象。
2、static静态块
Static块属于类的代码块，在类加载期间指向代码块，只执行一次，可以用来在软件中加载静态资源。
/** * instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。 * * instanceof 是 Java 的保留关键字。它的作用是测试它左边的 * 对象是否是它右边的类的实例（实例指的是“类”在实例化之后叫做一个“实例”。 * 实例化：通常把用类创建对象的过程称为实例化），返回 boolean 的数据类型。 */
4、final修饰变量
1、final关键字修饰成员变量，表示变量不可被改变。
2、final修饰成员变量的两种方式初始化：
a. 声明的同时初始化
b. 构造函数中初始化
3、final关键字也可以修饰局部变量，使用之前初始化即可
5、final修饰方法
1、final关键字修饰的方法不可被重写。
2、使一个方法不能被重写的意义在于：防止子类在定义新方法使造成“不间意”重写。
6、final修饰类
1、final关键字修饰的类不可被继承。
2、 JDK中的一些基础类库被定义为final的，例如：String、Math、Integer、Double等。
3、使一个类不能继承的意义在于：可以保护类不被继承修改，可以控制滥用继承对系统造成的危害。
7、static final常量
1、static final修饰的成员变量称为常量，必须声明同时初始化，不可被改变。
2、static final常量会在编译期被替换，例如：
十四、抽象类（abstract）
抽象类描述：（在Java语言中使用abstract class来定义抽象类）
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
抽象方法:
1、由abstract修饰
2、只有方法的定义，没有具体的实现(连{ }都没有)
如果一个方法使用 abstract 来修饰，则说明该方法是抽象方法，抽象方法只有声明没有实现。需要注意的是 abstract 关键字只能用于普通方法，不能用于 static 方法或者构造方法中。
抽象方法的 3 个特征如下：
1）抽象方法没有方法体
2）抽象方法必须存在于抽象类中
3）子类重写父类时，必须重写父类所有的抽象方法
注意：在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类重写，而如果使用了 private 声明，则子类是无法重写的。
抽象类:
1、由abstract修饰
2、包含抽象方法的类必须是抽象类
不包含抽象方法的类也可以声明为抽象类------我乐意
3、抽象类不能被实例化
4、抽象类是需要被继承的，派生类:
4.1、重写所有抽象方法--------常用
4.2、也声明为抽象类----------一般不这么做
5、抽象类的意义:
5.1、封装派生类所共有的属性和行为---------代码复用
5.2、给所有派生类提供统一的类型-----------向上造型
5.3、可以包含抽象方法，为所有派生类提供统一的入口
派生类的具体行为不同，但入口是一致的
设计规则:
1、将派生类所共有的属性和行为，抽到超类中--------抽共性
2、所有派生类的行为都一样，设计普通方法
所有派生类的行为都不一样，设计为抽象方法
十五、接口（Interface）
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现（implements）接口的方式，从而来实现接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
接口与类相似点：
1）一个接口可以有多个方法。
2）接口文件保存在 .java 结尾的文件中，文件名使用接口名。
3）接口的字节码文件保存在 .class 结尾的文件中。
4）接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别：
1）接口不能用于实例化对象。
2）接口没有构造方法。
3）接口中所有的方法必须是抽象方法。
4）接口不能包含成员变量，除了 static 和 final 变量。
5）接口不是被类继承了，而是要被类实现。
6）接口支持多继承（接口不能继承类，接口只能继承接口）。
接口特性：
1）接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
2）接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
3）接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
抽象类和接口的区别：

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
   **注：JDK 1.8 以后，接口里可以有静态方法和方法体了

2、static修饰方法
1、通常的方法都会涉及到对具体对象的操作，这些方法在调用时需要隐式传递对象的引用（this）。
2、static修饰的方法则不需要针对某些对象进行操作，其运行结果仅仅与输入的参数有关，调用时直接用类名引用。
3、static在调用时没有具体的对象，因此在static方法中不能对非static成员进行访问，static方法的作用在于提供一些“工具方法”和“工厂方法”等。
3、static静态块
Static块属于类的代码块，在类加载期间指向代码块，只执行一次，可以用来在软件中加载静态资源。
4、final修饰变量
1、final关键字修饰成员变量，表示变量不可被改变。
2、final修饰成员变量的两种方式初始化：
a. 声明的同时初始化
b. 构造函数中初始化
3、final关键字也可以修饰局部变量，使用之前初始化即可
5、final修饰方法
1、final关键字修饰的方法不可被重写。
2、使一个方法不能被重写的意义在于：防止子类在定义新方法使造成“不间意”重写。
6、final修饰类
1、final关键字修饰的类不可被继承。
2、 JDK中的一些基础类库被定义为final的，例如：String、Math、Integer、Double等。
3、使一个类不能继承的意义在于：可以保护类不被继承修改，可以控制滥用继承对系统造成的危害。
7、static final常量
1、static final修饰的成员变量称为常量，必须声明同时初始化，不可被改变。
2、static final常量会在编译期被替换，
十四、抽象类（abstract）
抽象类描述：（在Java语言中使用abstract class来定义抽象类）
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
抽象方法:
1、由abstract修饰
2、只有方法的定义，没有具体的实现(连{ }都没有)
如果一个方法使用 abstract 来修饰，则说明该方法是抽象方法，抽象方法只有声明没有实现。需要注意的是 abstract 关键字只能用于普通方法，不能用于 static 方法或者构造方法中。
抽象方法的 3 个特征如下：
1）抽象方法没有方法体
2）抽象方法必须存在于抽象类中
3）子类重写父类时，必须重写父类所有的抽象方法
注意：在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类重写，而如果使用了 private 声明，则子类是无法重写的。
抽象类:
1、由abstract修饰
2、包含抽象方法的类必须是抽象类
不包含抽象方法的类也可以声明为抽象类------我乐意
3、抽象类不能被实例化
4、抽象类是需要被继承的，派生类:
4.1、重写所有抽象方法--------常用
4.2、也声明为抽象类----------一般不这么做
5、抽象类的意义:
5.1、封装派生类所共有的属性和行为---------代码复用
5.2、给所有派生类提供统一的类型-----------向上造型
5.3、可以包含抽象方法，为所有派生类提供统一的入口
派生类的具体行为不同，但入口是一致的
设计规则:
1、将派生类所共有的属性和行为，抽到超类中--------抽共性
2、所有派生类的行为都一样，设计普通方法
所有派生类的行为都不一样，设计为抽象方法
十五、接口（Interface）
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现（implements）接口的方式，从而来实现接口的抽象方法。
接口与类相似点：
1）一个接口可以有多个方法。
2）接口文件保存在 .java 结尾的文件中，文件名使用接口名。
3）接口的字节码文件保存在 .class 结尾的文件中。
4）接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别：
1）接口不能用于实例化对象。
2）接口没有构造方法。
3）接口中所有的方法必须是抽象方法。
4）接口不能包含成员变量，除了 static 和 final 变量。
5）接口不是被类继承了，而是要被类实现。
6）接口支持多继承（接口不能继承类，接口只能继承接口）。
接口特性：
1）接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
2）接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
3）接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
抽象类和接口的区别：

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
   注：JDK 1.8 以后，接口里可以有静态方法和方法体了。
   十六、内部类
   java内部类的几种类型：成员内部类，静态内部类，方法内部类，匿名内部类。
   成员内部类：成员内部类是类内部的非静态类。成员内部类不能定义静态方法和变量（final修饰的除外）。
   静态内部类：
   静态内部类是 static 修饰的内部类，这种内部类的特点是：
   1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问。
   2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与 内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员。
   3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
   方法内部类（局部内部类）：
   方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
   需要注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
   匿名内部类：
   匿名类是不能有名称的类，所以没办法引用他们。必须在创建时，作为new语句的一部分来声明他们。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。
   十七、枚举
   枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。
   1、声明枚举
   声明枚举时必须使用 enum 关键字，然后定义枚举的名称、可访问性、基础类型和成员等。
   任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。
   提示：如果没有显式地声明基础类型的枚举，那么意味着它所对应的基础类型是 int。
   2、枚举类
   Java 中的每一个枚举都继承自 java.lang.Enum 类。当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。