JAVA笔记 第一章-第七章

初识Java

1. 了解Java的历史由来

编程语言流行趋势：Tiobe、PYPL排行榜

apache、spring、eclipse、alibaba、google…

sun公司(升阳公司)正式在1995年公开了Java。

Sun公司打算进军机顶盒，C不太合适，于是打算开发一个新的编程语言oak。

詹姆斯·高斯林

2009年 Sun被Oracle(甲骨文)收购了，所以自然Java这些全都是Oracle。

目前，Java2平台有3个版本，它们是适用于小型设备和智能卡的Java2平台Micro版（Java2 Platform Micro Edition，JavaME、J2ME）、适用于桌面系统的Java 2平台标准版（Java2 Platform Standard Edition，Java SE、J2SE）、适用于创建服务器应用程序和服务的Java 2平台企业版（*Java*2 Platform Enterprise Edition，Java EE*、J2EE)

Java SE --> Java EE(网站，服务器)。

什么是程序？

现实“程序”：在现实生活中固有的一套流程。

1.拿上你的卡 2.来到银行 3.取号 4.排号 5.来到柜台 说你要取多少钱 6.输密码 7.取钱 8.走人

计算机领域的程序：

​ 指令：老板给秘书发号施令 我们是老板 计算机就是秘书。

​ 指令给多了 就成为了程序。

描述现实生活中的实际场景，将其转换为计算机指令的形式展示出来。

我们希望给计算机发指令，通过计算机能识别的语言，计算机识别二进制。011010010101

后来转换为了字母，人类能识别的语言 (编程语言)。

2. 了解Java虚拟机与跨平台原理

跨平台：我的程序可以在windows平台上运行，还可以在android上运行、ios、linux…

write once , run it anywhere. 写一次 在任何地方都可以运行。

.class 字节码文件 一种伪二进制文件

它需要运行在JVM上(Java虚拟机)

3. 熟练掌握安装、配置JDK的开发环境

编程人员：JDK(Java Development Kit Java开发工具包) JDK里内置一套JRE

客户：JRE(Java Runtime Environment Java运行环境)

以后开发类的软件 安装到一个develop 文件夹！

源码：源代码 曾经编写此程序写的代码

我们要使用Java开发程序，需要用到的是jdk安装目录下的bin目录下的java.exe和javac.exe。

但是这两个程序无法直接双击打开！需要在DOS命令行运行。

进入DOS命令行：Windows+R键 -> 输入cmd 回车

如果是电脑权限比较高的用户：在开始菜单直接输入cmd -> 右键以管理员身份运行

常用命令：

• 切换盘符 :磁盘名:
• 创建文件夹：mkdir 文件夹名(make directory)
• 进入某个文件夹：cd 文件夹路径
• 查看某个文件夹下的所有内容：dir(directory)
• 每个文件夹下其实都有两个你看不到的文件夹 .(当前文件夹) 和 ..(上一级文件夹)
• 返回上一级文件夹：cd ..
• 在DOS中运行.exe程序可以忽略掉.exe扩展名

查看当前安装的Java版本：java -version

我们发现为了运行此程序 需要编写很长的路径才能找到它去运行。

配置环境变量就可以解决此问题。

path(路径)环境变量：

当在DOS中执行输入了程序名要执行的时候，系统它会先去当前目录下找有没有这个程序，如果找不到，那么就会去path环境变量中寻找你配置过的路径，然后在这些路径中寻找是否有指定程序，如果有就执行，没有报错！

windows+E -> 在空白处右键属性 -> 高级系统设置 -> 高级选项卡 -> 环境变量 -> 系统变量

-> 新建 -> 变量名：JAVA_HOME 变量值：你的jdk安装目录的bin目录的上一级路径 -> 点击path环境变量 ->编辑 -> 在其中插入%JAVA_HOME%\bin; (如果你有oracle自动配置的环境变量 删了就可以了)-> 确定。

4. 熟练掌握使用记事本开发第一个Java程序

步骤：

1.新建记事本

2.编写源代码 .java文件

public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello World!");
	}
}

3.编译源代码 (这个源代码是给我们看的 我们要将其翻译给计算机运行 .class文件（字节码文件/伪二进制/byte code）)

javac HelloWorld.java

4.运行字节码文件

java HelloWorld

Java程序注意事项：

1. 类名必须和文件名相同！采用帕斯卡命名法/大驼峰命名法。

   首字母大写，如果有多个单词，每个单词的首字母都大写。

2. 前期我们的main绝对要写 而且不能写错！

   public static void main(String[] args){}

3. 每一块内容 必须要有{} 而且一一对应

4. 每一条语句 必须以;结尾

5. Java是严格区分大小写

6. 要有缩进效果，同一级的要保持对齐 表示下一级的时候 要有4个空格缩进。

7. 掌握输出语句

System.out.print(); // 输出完 不换行

System.out.println();// 输出完 换行

转义字符：有特殊含义的文字 它的使用必须在""中

System.out.print("xxxx\n");

\n ： 换行

\t：表示一个制表位 有时候会自动调整结构

注释：为了方便自己和他人阅读代码所做出的解释性内容。它不会被编译，仅能在源代码中查看。

程序的编写未来是给人看的 不是给机器看的。

要求：在前期学习内，注释的量保证在40%以上

注释应该出现在要解释的内容的上方 或者右侧

单行注释：//

多行注释：/* */

6.会使用Eclipse开发程序

IDE：一般包括代码编辑器、编译器、调试器和图形用户界面等工具。集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务套。

它的作用：提升你的开发效率。

主流的开发Java的IDE：

1.Eclipse：Eclipse基金会 免费 Java EE 被 Oracle正式移交给 Eclipse基金会 Jakarta EE。

2.MyEclipse：IBM和另一个…出品的 收费 MyEclipse是基于Eclipse产生的定制版 主要用于Java EE

3.IDEA：Jet Brains公司出品 收费

Eclipse：

​ Mars版本 Java 1.7

​ Neon版本 Java 1.8

​ Oxygen版本 Java 1.8

​ Photon版本 Java 1.8

工作空间(workspace)：项目存储在哪 在IDE里面 源代码是存放在项目中的
进入Eclipse：

1.切换到Java工作模式

2.切换字符编码为UTF-8

window -> 首选项 -> 搜索workspace -> 选择第二个workspace -> 修改Text File Encoding -> UTF-8。

3.新建Java Project

​ JRE：运行环境 必须要有

​ src(source)：存放源代码

4.在src下新建package（包）

​ 包：用于给源代码区分位置的

​ 规范：公司域名的倒序+你自定义的名称 包名必须全部小写

​ www.kgc.cn ： cn.kgc.xxxx

5.在package上新建Class（类）

​ 写上类名 然后完成 一个基本的类结构就出来了

6.编写你的源代码

7.右键 -> run as -> Java application 运行你写的Java程序

7. 会使用反编译工具

编译（compile）：将.java文件 -> .class文件

反编译（decompile）：将.class文件 -> .java文件

jad

jd-gui
变量和数据类型

了解什么是变量 为什么需要它

计算机中的内存分类:

RAM：运行时存储 我们的计算机程序 在运行的时候 数据就会临时存储在RAM中。

​ 如果不持久化，或者突然断电，它的数据就丢失了。

ROM：只读存储(持久化存储) 文件存储

变量(可以改变的量)：Java程序在运行过程中，会将数据以圈占地盘的形式存储起来。

因为如果真正要寻找变量，如果依靠内存地址，非常的繁琐(0x1212x12)，于是我们就将变量起了个名。(变量名)

类比：我们去酒店开房，酒店前台不会以“三楼左转走100米，再右转50米的尽头的房间的隔壁房间”，所以你看到酒店前台都是以客房号来称呼你，“302的客人”。

变量的三要素：

变量名 — 酒店的房间名

变量值 — 酒店房间入住的客人

变量的数据类型 — 酒店房间的类型

1. 掌握标识符和关键字

变量三要素：变量名的命名规范：

1. Java中的变量名必须且只能是由 数字、字母、下划线和$组成，而且数字不能开头。

2. 见名知义(a=1000; money=1000; b=支付宝; name=支付宝;)

3. 采用小驼峰命名法

   thelengthofknife -> theLengthOfKnife

   首字母小写，如果有多个单词，后面的每个单词，首字母都要大写。

4. 或者可以采用连字符命名法

   the_length_of_knife

5. 不能使用关键字(Java语言中 为了表示特定的含义 而使用的单词 在IDE中会变色)

   也最好不要使用保留字。 goto var … 保留字 指的就是在Java语言还没有指定含义的单词 但是这些单词未来可能有特殊的含义。

6. 掌握变量和常量的使用

变量的使用：

1.先声明再赋值

数据类型 变量名;

变量名 = 变量值;

2.声明的同时并赋值

数据类型 变量名 = 变量值;

常量：因为在程序运行中，有些内容不希望被重新赋值，它的值是固定的。

被final修饰的变量

常量的命名规范：

每个字母都大写 如果有多个单词 单词之间以_连接。

举例：PI 、 CURRENT_PAGE_NO

3. 掌握Java中的数据类型

变量三要素-数据类型：

数值：

​ 整型：byte short int long (取值范围越来越大)

​ 非整型 ：float double (取值范围越来越大)

非数值：

​ 字符：char 例如：‘男’ ‘f’

​ 字符串：String 例如：“xxxxxx”

​ 布尔类型：boolean 例如：true 真 false假

按照基本数据类型和引用数据类型划分：

基本数据类型：byte short int long float double char boolean

引用数据类型(难点)：类(String是一个类)、数组、集合、接口、枚举

4. 掌握数据类型转换

IDE使用技巧：

1. 重命名：F2(可能还需要按住fn) / 右键你要更改的内容 -> refactor -> rename

3. 掌握Scanner的使用

4. 导入Scanner 这个导包的代码放在类声明上包声明下。

   import java.util.Scanner;

5. 创建Scanner对象

   Scanner input = new Scanner(System.in);

6. 使用

   输入字符串：input.next();

   输入整数：input.nextInt();

   输入小数：input.nextDouble();

7. 运算符

赋值运算符

=号不再表示相等 表示赋值

算数运算符

+ - * / %

++ –

++表示自增

–表示自减

前++和后++的区别：

如果正常使用单独作为一条语句++num1;，那么前++和后++都是一个意思。

但是如果是参与到与其他元素的使用，它是根据++的顺序有不同的变化。

这个时候的前++表示先自增再使用，后++表示先使用再自增。

public class Demo3 {
	public static void main(String[] args) {
		char alpha1 = 'A';
		// 字符如果使用自增  那么会先转换为对应的ASCII码值 然后再进行自增 然后再转换为对应的char类型
		// alpha1 ++;
		// 如果参与到数学运算  那么这时候就会将字符转换为ASCII码值 然后进行计算
		System.out.println(alpha1+10);
	}
}

关系运算符

== 表示相等

!= 表示不相等

逻辑运算符

&&和单个&的区别：

短路与和单个&都表示并且，必须多个条件同时为true结果为true。

但是单个&，无论你是否能够通过第一个条件得到最终结果，都会计算后面的表达式。

而短路&它如果可以通过第一个条件得到最终结果的话，后面的就不需要计算了。

单个&还可以表示位与运算。

条件运算符(三元/三目运算符)

条件表达式 ? 为true时的结果 : 为false时的结果;

// 需求：如果你有钱就是大爷  没钱滚
int money = 1;
System.out.println(money > 0 ? "大爷欢迎来玩~" : "没钱还来潇洒！滚远远的~");

关于优先级：()提升优先级

选择结构

1. 掌握if(如果)选择(分支)结构

掌握基本if

if(条件){
    // 条件成立时执行的内容
}

掌握if-else

if(条件){
    // 条件成立
}else{
    // 条件不成立
}

掌握多重if

if(条件1){
    
}else if(条件2){
    
}else{
    ....
}

注意事项：

1. 自上而下执行条件判断，只要有一个条件满足 剩下的条件不再执行
2. 可以结合n个else if，但是else if不能单独使用
3. 可以结合else使用
4. 多重if如果是范围性的判断 必须要注意顺序

掌握嵌套if

一个选择结构里 可以继续嵌套n层选择结构 而且没有强制要求必须是哪种

if(){
    if(){
        ....
    }
}

public class Demo1 {

	public static void main(String[] args) {
		// 需求：坐地铁
		
		double theLengthOfKnife = 8;
		int hasTicket = 1; // 1 有票  0无票
		// 1.如果安检过程中检查到你携带的大刀超过了9cm
		if(theLengthOfKnife < 9) {
			System.out.println("进站准备检票");
			// 2.如果安检通过了 你有票就可以进站
			if(hasTicket == 1) {
				System.out.println("这是开往幼儿园的车！");
			}else {
				System.out.println("没票只能在大厅转悠一下了！");
			}
		}else {
			System.out.println("带走！怎么哪都有你！");
		}
		
	}

}

2. 掌握switch(开、关)选择(分支)结构
   switch的表达式只支持 int String enum(枚举)。

自动类型转换：

byte short -> int

char -> int

JDK是在1.7版本支持String类型的。

switch(表达式){
    case 常量1:
    	// 执行语句
    	break;
    case 常量2:
    	// 执行语句
    	break;
    ....
    default:
    	// 执行语句
    	break;
}

注意事项：

1. switch只能用于等值判断

2. switch中的每一个case后都必须加上break，否则会出现case穿透

   break有时候不加会有特别的效果,根据你需求决定,但一般采用上方规范。

3. 无论是否需要默认情况,都推荐加上default

循环结构

1. 掌握while循环结构(其次于for)

// 1.初始化循环变量
xxxxx
// 2.循环条件
while(条件表达式){
    // 3.循环操作(循环体)
    // 4.更新循环变量(循环出口)
}

public class Demo3 {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		/*
		 * 循环条件：不合格
		 * 循环操作：执行学习任务
		 */
		// 1.循环的初始值
		String pass = "n";
		// 2.循环条件
		// 如果是基本数据类型比较  可以使用==   但是字符串是个引用数据类型 比较内容相等时 必须使用equals()
		while(pass.equals("n")) {
			// 3.循环操作
			System.out.println("上午阅读教材，学习理论部分");
			System.out.println("下午上机编程，掌握代码部分");
			
			// 4.循环出口
			System.out.print("老师，他合格了吗？(y/n)：");
			pass = input.next();
		}
		System.out.println("恭喜合格！");
	}

}

2. 掌握do-while循环结构(前期)

do{
    // 循环操作
}while(循环条件);

do-while和while区别：do-while无论条件是否满足 都至少会执行一次！

3. 掌握for循环结构(后期用的最多)

循环次数固定的场景。

for(初始化变量;条件;循环出口){
    // 循环操作
}

// 可能未来我们会使用到死循环

// 死循环
/*for(;;) {
	System.out.println("xxxxxxxxxxxxx");
  }*/
		
while(true) {
	System.out.println("xxx");
}

Java的多重循环和程序调试

1. 掌握Java二重循环(多重/嵌套)

注意：

1. 外层循环控制行 内层循环控制列(每行打印的内容)

2. 外层循环执行一次 内层循环执行一遍

3. 一般多重循环值的就是二重循环

4. 使用跳转语句控制程序的流程

return结束程序 结束当前的方法,返回到方法的调用者处。

break中断：switch中见过 可以结束掉某个case

​ 表示终止循环,但是如果是出现在内层循环中,它只是结束了当前循环,外层的没有影响。

for(int i = 0 ;i < 10; i++){
    for(int j = 0; j < 10; j++){
        syso("*");
        if(j == 3){
            break;
        }
    }
}

continue 继续：表示结束掉本次循环,进入下一次循环。

3. 掌握程序的调试(debug)

断点调试：因为程序执行很快,一晃而过 所以我需要让它在我需要查看的位置停下来慢慢执行。

断点调试步骤：(未来更多的使用步骤 请见上课老师)

1. 打断点 break point(双击左侧的竖栏 注意：是在方法中非注释的位置打 )

2. 以debug as运行 (当运行到断点处时，程序会中断，在断点处等待你调试)

   这一行被选中的代码，它处于将要执行，还未执行的状态。

   此种执行方法 会触发切换debug视图对话框

3. 按F6或者按Step over键 可以执行当前暂停的这一行代码

   如果想看一些判断的结果,可以选中你想判断的地方,然后右键->inspect查看

4. 在一行一行执行的过程中，可以随时在debug视图查看变量表 监测变量的变化,或者直接鼠标放在变量上，查看变量的值。

5. 在查看代码执行过程中，如果有些代码已经清楚执行结果之后，想看关键点，那么可以直接点击F8或者Resume按钮，快速放行掉非断点代码内容。(它会直接来到下一次的断点位置 中间直接快速执行了)

面向对象-类和对象

数据存储方面：

​ 变量：只能存储一个 如果内容多了 存储起来需要定义n个变量 麻烦

​ 数组：可以存储一组相同数据类型的数据。

​ 数据类型相同：

​ 如果用数组存储一个人的信息/比较丰富的信息的话，不太方便。

​ 例如：吃货联盟中存储订单和菜品信息。

​ 纵向数组：我们定义了好多个数组，认为不同数组中，索引相同的数据，都是同一个信息。

​ 升级：不方便,所以想存储更多元化的数据，我们这阶段学习对象，它可以存储数据。

​ 长度不可变：未来第三阶段要学习集合，它可以解决这问题。

​ 对象：

编码方面：(程序的架构)

​ 面向过程开发：想让它干嘛，你就写对应的代码。你在写吃货联盟的时候，需要展示菜品或订单信息，你就将那一堆的代码，放那儿就可以了。(代码无法重用,扩展性差,可维护性差,阅读性差)

​ 面向方法/功能/函数开发：本阶段我们会将以前重复的代码，按功能切分，抽取成为一个方法。以后直接调用方法即可快速实现功能。

​ 面向对象开发(OOP)：** (陈鑫卖煎饼->升职加薪->迎娶高富帅开酒店)

1. 掌握类和对象的关系

什么是对象？

万物皆对象。你身边的任何一个，你可以叫的出名或者可以单独区分出来的一个实体，它就是对象。

对象：描述客观事物的一个实体，它由一组属性和方法构成。

​ 属性(特征)：描述一个对象的信息。

​ 例如：姓名、年龄、性别、游戏中的法防、物防、法功、家族、帮派、称号…

​ 方法(操作)：描述一个对象的行为。

​ 例如：猫吃鱼、狗吃肉、奥特曼专打小怪兽。

什么是类？

类：人类、鸟类、非人类，分类…

​ 由一组具有相同属性(不是指属性值一样，而是指属性名，例如：学生对象都有姓名、年龄等属性)和相同行为的对象中抽取出来的一个抽象的概念(分类)。

类和对象的关系：类是一个模板，对象是类的一个具体实例。

程序中对象和类

编程：将现实生活中的场景以计算机指令的形式描述出来。

Java是一个不完全面向对象的编程语言。(因为Java中有基本数据类型 byte short int long float double boolean char…)。

所有的Java程序都是以类为组织单元。

2. 掌握如何定义类（对象的模板）

类是一个引用数据类型。

一个类并不是必须要有main方法！main方法是程序的入口！一个程序只要有一个main方法作为程序入口即可！(大门只有一个！)

public class 类名{
    // 一组属性
    
    // 一组方法
}

public class HelloWorld{
    public static void main(String[] args){
        syso(xxx);
    }
}

/**
 * 学生类  是学生对象的一个模板
 * @author Charles7c
 * 2019年1月9日 下午2:57:22
 */
public class Student {

	// 一组属性/成员变量/[实例(对象)]变量
	/** 姓名 */
	public String name;
	/** 年龄 */
	public int age;
	/** 体重 */
	public double weight;
	/** 学号 */
	public int id;
	
	// 一组方法/成员方法
	/** 学习 */
	public void study() {
		System.out.println(name+"在学习！");
	}
	
	/** 自我介绍 */
	public void printInfo() {
		System.out.println("姓名："+name);
		System.out.println("年龄："+age);
		System.out.println("体重："+weight);
		System.out.println("学号："+id);
	}
	
}

在Eclipse中，Ctrl+Shift+T 可以全局搜索类。

注意事项：

1.  一个.java文件中可以定义多个类，但是只能有一个类被public修饰，被public修饰的类，它的类名和文件名保持一致。(在无特殊情况一个.java文件只写一个类)
2.  一个类并不是必须要有main方法，同样一个类也不是必须要有一堆属性和一堆方法，这些属性和方法到时候是根据我们的需求决定。
3.  定义类的信息时候也要注意好对齐和规范。

3. 掌握如何定义对象

语法：类名 对象名 = new 类名();

public class Test {

	public static void main(String[] args) {
		
		// 创建对象
		// Scanner scanner = new Scanner(System.in);
		// 创建学生对象
		Student stu = new Student();
		// 创建老师对象
		Teacher teacher = new Teacher();
		
		// 给对象的属性赋值(存储一些信息)
		stu.name = "布俊彪";
		stu.age = 18;
		stu.id = 700;
		stu.weight = 180;
		
		// 给老师信息赋值
		teacher.name = "邢老师";
		teacher.major = "COT";
		teacher.gender = '女';
		teacher.teachAge = 30;
		
		// 使用属性值
		System.out.println(teacher.name);
		// 调用方法
		stu.printInfo();
		stu.study();
		System.out.println("----------------------");
		teacher.printInfo();
		
	}

}

4. 熟悉基本的方法定义(下一章才是重点)

方法：就是一个代码的组合，是一个功能。

// 通过用户名和密码获取用户信息

getUserByUsernameAndPassword()

初识方法的基本的语法：

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

今天我们学习的方法 没有返回值类型，没有返回值类型的话 定义为void(空、无效的)

方法调用的注意事项：

1. 同一个类中(不包含static情况)，调用方法只需要直接写`方法名();`即可。同一个类中，你都看到它了，调用一下很简单。
2. 不同的类中(不包含static情况)，方法间相互调用，需要先创建对象，然后`对象名.方法名();`不同类中，你不创建对象，我怎么知道你是谁的方法。

方法重写和多态

1. 方法重写的作用和使用

方法重写：子类继承了父类的方法后，如果发现在需求下，父类的某些方法不太强大，我们就可以在子类中进行重写。

	/**
	 * 宠物自白
	 */
	@Override // 注解不报错 说明你写的就是方法重写  (规范：必须要加)
	public void showMyself() {
		super.showMyself();
		System.out.println("我的品种："+breed);
	}

【方法重写和方法重载的区别：(面试题)】

方法重写特点：

​ 在继承中的子类中，子类继承了父类的方法后，方法名相同，参数列表也相同。

​ 方法的返回值类型不能大于父类（学了多态就理解了）。

​ 方法的访问修饰符不能严于父类。 (父类是默认的 你写了私有的。)

​ 了解：不能比父类抛出更多的和更大的异常。(学了异常之后就懂了)

方法重载特点：

​ 在同一个类中，方法名相同，参数列表不同（类型、个数、顺序不同…），这种情况就是方法重载。与方法的返回值类型和访问修饰符无关。

留的疑问：为什么在父类中方法不强大，子类又写一遍，还不能把父类中的删掉？美其名曰方法重写？

和多态有关。

2. 深入理解继承并了解Object类

Object：是Java中最顶级的类。超类(super class)

任何类都直接或者间接继承自Object。

Ctrl+T：查看继承体系

Ctrl+Shift+T：搜索类

Ctrl+O：查看本类中的所有属性和方法

Object它有很多方法，只要是定义一个类，这些方法都可以被定义的类所继承过去。

1. toString(); // 转换为字符串

   public String toString() { // 默认输出当前对象的伪地址值
      return getClass().getName() + "@" + Integer.toHexString(hashCode());
   }
   

2. equals(); // 判断相等

   public boolean equals(Object obj) { // 默认是用==来进行比较的
        return (this == obj);
   }
   

3. hashCode(); // 获取哈希值

4. getClass(); // 获取字节码对象

这些方法在Object中都有基本的实现内容，但是我们的需求一直多变，所以Object中的方法，不太适合，那么就可以进行方法重写。

例如：String类就默认进行了重写equals()方法。

【==和equals的区别？(面试题)】

== 如果比较基本数据类型，比较的是值内容。

而如果比较引用数据类型，比较的是内存地址。

equals方法，默认情况下(Object)和==是一样的。

但是在String中重写了equals之后就可以进行比较内容了。

String：字符串 它本质上就是一个字符数组。

下方是字符串重写的equals方法：

例如调用：
		String name = "xxx";
		String name1 = "xxx";
		name.equals(name1);


public boolean equals(Object anObject) {
        // 比较内存地址   如果地址值相同  说明是同一个 那么直接返回true
        if (this == anObject) {
            return true;
        }
    	
    	// 判断anObject 是不是字符串类型的 如果不是没法比 直接结束
        if (anObject instanceof String) {
            // 如果anObject是一个字符串类型  那么首先向下类型转换为String
            String anotherString = (String)anObject;
            // 获取this它的value数组(字符数组)的长度
            int n = value.length;
            // 判断是否字符串的长度一致  如果不一致 直接结束
            if (n == anotherString.value.length) {
                // 比较字符是否完全一致
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    // 只要其中发现不一样的字符  立马结束
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                // 如果一切正常  返回true
                return true;
            }
        }
        return false;
    }

// Alt+Shift+S h 生成重写后的hashCode和equals方法。

3. 理解如何重写equals()方法

@Override
public boolean equals(Object obj) {
	if (this == obj)
		return true;
	if (obj == null)
		return false;
	if (getClass() != obj.getClass())
		return false;
	Student other = (Student) obj;
	if (age != other.age)
		return false;
	if (id != other.id)
		return false;
	if (name == null) {
		if (other.name != null)
			return false;
	} else if (!name.equals(other.name))
		return false;
	return true;
}

4. 多态的作用和使用

面向对象三大特性：多态

5. 掌握instanceof关键词

instance：实例

instanceof：…的实例

可以判断是否属于某个类型的实例

6. 掌握向上和向下转型

自动类型转换和强制类型转换。

继承

static：静态的

作用：

1. 可以用来修饰成员变量 -> 静态变量/类变量

静态变量它是随着类的加载而加载，它被这个类的所有对象共享。

普通成员变量(实例变量)它是随着对象的创建而产生，在不同的对象之间，是相互独立的。

2. 可以用来修饰方法 -> 静态方法

   备注：A：B：都是方法 如果被(S)修饰就是静态的。

   静态方法的调用：

   ​ 同一个类中方法之间调用：

   ​ A(S) -> B：不能直接调用，因为B不是静态方法它是随着对象的调用才产生的。

   ​ B -> A(S)：可以创建对象去调用，也可以直接就使用。

   ​ A(S) -> B(S)：可以直接调用。

   ​ 不同类中的方法之间调用：**(B是一个类中 A是另一个类中的方法)

   ​ B -> A(S)：可以创建对象去调用，也可以直接类名.方法名();

   ​ B(S) -> A(S)：可以创建对象去调用，也可以直接类名.方法名();

   普通方法的调用：

   ​ 同一个类中方法之间调用：

   ​ 直接调用。 方法名():

   ​ 不同类中的方法之间调用：

   ​ 它的使用必须创建对象之后才能调用。

3. 可以用来修饰代码块 -> 静态代码块

   代码块/构造代码块/成员代码块：每一次创建对象 都会执行。优先于构造方法。

   {
       
   }
   

   静态代码块：类加载的时候只执行一次！

   static{
       
   }
   

继承的作用

便于复用代码。

将子类中公有的代码，提取出来存储到父类中，到时候用子类继承父类就可以重复使用父类中的代码。

继承的使用

定义父类：

public class Pet{
    // 子类公有的代码
}

定义子类：

public class Dog extends Pet{
    // 子类特有的代码
}

面向对象的三大特性之一就是继承。

Java：单根继承，一个子类只能有一个直接父类。(一个人只可能有一个亲爹)

在设计使用继承优化时，尽量符合is a的关系。

例如：猫 is a 宠物 学生 is a 人

理解继承

父类不是所有的内容都能被子类所继承。

1. 父类私有的(private修饰的)不能被继承
2. 父类的构造方法不能被继承
3. 如果父类和子类不是在同一个包中，那么父类中的默认修饰符修饰的内容不能被继承

protected：受保护的 在不同包中 只要是有子父类继承关系 那么在子类中就可以访问信息。

访问修饰符\访问权限	在同一个类中	在同一个包中	在子类中	在项目任何位置
private	√
默认修饰符	√	√
protected	√	√	√
public	√	√	√	√

执行流程的特点：（构造的执行流程：经常出现在笔试题中）

1. 子类的构造方法中，如果没有显示的去调用父类的构造或者调用自己的其他构造。

那么：系统会默认调用父类的无参构造。(默认有super()调用)

public Dog(){
    super();
}

Super关键字：

this：当前对象 谁在调用这个方法谁就是对象

this(); // 调用自己的构造

this.方法(); // 调用自己的方法

this.成员变量(); // 调用自己的属性

super：**父类的对象 谁是它的父类，这个对象就属于谁。

super(); // 调用父类的构造

super.方法(); // 调用父类的方法

super.成员变量(); // 调用父类的属性

2. 如果子类在构造中，显示的去调用了父类的某个构造。

   那么：系统就会去执行对应的构造，而不再执行默认的无参构造。

   public Dog(){
       super("xxxx");
   }
   

3. 如果子类在构造中，显示的去调用了自己的某个构造。

   那么：系统就会先去执行你自己的那个构造，而那个构造中也会根据上两条情况去执行对应的父类构造。

   public Dog(){
       this("xxx");
   }
   public Dog(String name){
       super(); // 和上两条一致
       // .....
   }