qq_42186847

狂神说Java--Java学习笔记(基础合集)

笔记参考来源狂神说Java视频https://www.bilibili.com/video/BV12J41137hu
本篇笔记有点长，可以根据目录定位，建议配合视频学习。

预科

什么是计算机

名称：Computer，全称电子计算机，俗称电脑。
定义：能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。
组成：由硬件和软件组成。
形式：常见显示有台式计算机、笔记本计算机、大型计算机等。
应用：科学计算、数据处理、自动控制、计算机辅助设计、人工智能、网络等领域。

硬件及冯诺依曼结构

计算机硬件

组成：CPU，主板，内存，电源，主机箱，硬盘，显卡，键盘、鼠标，显示器。

冯诺依曼结构

软件及软件开发

计算机软件

Windows常用快捷键

Alt+f4关闭窗口 Shift+Delete永久删除 ctrl+w自动保存

死机：任务管理器结束进程

基本的Dos命令

打开CMD的方式

开始+系统+命令提示符
win键+R+输入cmd (推荐使用)
在任意的文件夹下，按住Shift键+鼠标右击，打开命令行窗口
在资源管理器地址栏路径前面加 “cmd ”
管理员运行方式：命令提示符右键以管理员身份运行（最高权限运行）

常用的Dos命令

# 盘符切换 E:
# 查看当前目录下所有文件 dir
# 切换目录 cd /d E:\idea
# 返回上一级目录 cd ..
# 进入同级目录下的下一级目录 cd tmp(该目录下的文件名)
# 清屏 cls (clear screen)
# 退出终端 exit
# 查看电脑当前IP地址 ipconfig

# 打开计算器 calc
# 打开画图 mspaint
# 新建记事本 notepad

# 在当前目录新建文件夹 md test(文件夹名)
# 新建文件 cd> a.txt(文件名)
# 删除文件 del a.txt(文件名)
# 删除目录 rd test(目录名)

# ping命令(复制链接进入Dos直接单击鼠标右键粘贴)
	ping www.baidu.com

计算机语言发展史

第一代语言：机器语言
第二代语言：汇编语言
第三代语言：高级语言

高级语言

C、C++、Java、C#、Python、PHP、JavaScript …

大体上分为：面向过程与面向对象两大类

C语言是典型的面向过程的语言，C++，Java是典型的面向对象的语言

Java入门

Java帝国的诞生

Java特性与优势

简单性
面对对象
可移植性
高性能
分布式
多态性
多线程
安全性
健壮性

Java三大版本

Write Once，Run Anywhere
JavaSE: 标准版 (桌面程序，控制台开发…)
JavaME: 嵌入式开发 (手机，小家电…)，已经凉了
JavaEE: E企业级开发 (Web端，服务端开发…)，JavaSE为基础

JDK JRE JVM

JDK：Java Development Kit (Java开发者工具，包括 JRE，JVM)
JRE：Java Runtime Environment (Java运行时环境)
JVM：Java Virtual Machine (Java虚拟机，跨平台核心)

安装开发环境

卸载JDk

删除Java安装目录
删除环境变量JAVA_HOME
删除path下关于JAVA的目录
Java -version

安装JDK

百度搜索JDK8，找到下载地址
同意协议，下载电脑对应的版本，如64位操作系统下载 jdk-8u281-windows-x64.exe
双击安装JDK
记住安装路径
配置环境变量
1. 我的电脑-》属性-》系统高级设置-》环境变量
2. 系统变量新建–> JAVA_HOME 输入对应的jdk安装路径
3. path变量–>% JAVA_HOME%\bin
测试是否成功 cmd–>Java -version

Java基础

注释

单行注释 //
多行注释 /* */
文档注释 /** */

标识符和关键字

Java 所有的组成部分都需要名字。类名、变量名、方法名都被称为标识符

关键字

标识符注意点

所有标识符都应该以字母、$(美元符)、_(下划线) 开头
首字母之后可以是字母、$、_ 或数字任何字符组合
关键字不能作为变量名或方法名
标识符大小写敏感
可以用中文命名，但不建议使用，即使用拼音命名也Low

数据类型

强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
弱类型语言：JavaScript，Python
Java的数据类型分为两大类
- 基本类型（primitive type），有8大基本类型，此外都是引用类型
- 引用类型（reference type）

//整数
int num1 = 10; //最常用，只要别超过21亿（2^31-1）
byte num2 = 20; //-128~127
short num3 = 30;
long num4 = 30L; //long类型数字后面要加个L(尽量用大写，小写l容易与1搞混)

//小数：浮点数
float num5 = 50.1F; //float类型数字后面要加个F
double num6 = 3.141592653589793238;

//小数：浮点数
float num5 = 50.1F; //float类型数字后面要加个F
double num6 = 3.141592653589793238;

//布尔值：是非
boolean flag = true

类型转换

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
容量高–>低：

运算中，不同类型的数据先转化位同一类型，再进行运算。
- 强制转换，（类型）变量名，容量由高到低
- 自动转换，容量由低到高

//强制转换 （类型）变量名 高--低
//自动转换 低--高
int i = 128;
byte b = (byte)i; //强制转换 内存溢出 -128~127
double d =i; //自动转换

System.out.println(i); //128
System.out.println(b); //-128
System.out.println(d); //128.0
/*
   注意点：
   1.不能对布尔值进行转换
   2.不能把对象类型转换为不相干的类型
   3.在把高容器转换到低容量的时候，强制转换
   4.可能存在内存溢出，或者精度问题
 * */
System.out.println((int)23.7); //23 丢失精度
char c = 'a';
int n = c+1;
System.out.println(n); //98
System.out.println((char)n); //b

//当操作数比较大时，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000; //10亿，下划线不会被打印出来
System.out.println(money); //1000000000
int years = 20;

int total = money*years;  //数据大，溢出
System.out.println(total); //-1474836480

long total2 = money*years; //默认是int，转换前就有溢出问题
System.out.println(total2); //-1474836480

long total3 = money*(long)years; //先把一个数转Long
System.out.println(total3); //20000000000

变量、常量、作用域

变量是什么：就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型

Java变量是程序中最基本的存储单元，要素包括变量名，变量类型和作用域

//数据类型 变量名 = 值;
type varName [=value][{,varName[=value]}];
//可以使用逗号隔开同多个类型的变量，但不建议在一行定义多个变量

变量作用域

类变量（static）
实例变量
局部变量

public class Variable{    static int 	allClicks = 0; //类变量    String str = "hello world"; //实例变量    public void method(){        int i=0; //局部变量    }}

常量

常量：初始化后不能再改变的值，不会变动的值。

可以理解为一种特殊的变量，其值被设定后，在程序运行过程不允许被更改。

//常量一般用大写字符final 常量名=值;final double PI=3.14;

//修饰符 不存在先后顺序，static可以写final后面static final doube PI=3.14; //类变量，该类下的全局范围

变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写+驼峰原则：lastName
局部变量：首字母小写+驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写+驼峰原则：Man，GoodMan
方法名：首字母小写+驼峰原则：run()，fastRun()

运算符

int a=10;int b=20;System.out.println(a/b); //0System.out.println((double)a/b); //0.5long c=12300000000;System.out.println(a+b); //intSystem.out.println(a+c); //long 自动转换式子中容量大的数据类型

自增自减运算符

// ++自增 --自减 单目运算符int a = 3;int b = a++; //b=a,a=a+1 先赋值 即b=3 a=4int c = ++a; //a=a+1,c=a 先自增 即a=5 c=5System.out.println(a); //5System.out.println(b); //3System.out.println(c); //5

//幂运算 2^3 2*2*2=8double pow = Math.pow(2,3); // (底数，指数)double型System.out.println(pow); //8.0

//扩展：笔试题 i=5 s=(i++)+(++i)+(i--)+(--i) s=?int i=5;int s=(i++)+(++i)+(i--)+(--i);System.out.println(s); //24

逻辑运算符

&& 逻辑与运算：两个变量都为真，结果为true
|| 逻辑与运算：两个变量有一个为真，结果为true
! 取反，真变为假，假变为真

// 与(snd) 或(or) 非(取反)
boolean a = true;
boolean b = false;

System.out.println(a&&b); // false
System.out.println(a||b); // true
System.out.println(!(a&&b)); // true

int c=5;
boolean d = (c<5)&&(c++<5); //第一个值为false，后面就不进行判定了
System.out.println(d); //false
System.out.println(c); //5 c++未执行

位运算

/*
    A = 0011 1100
    B = 0000 1101

    A&B 0000 1101 按位与
    A|B 0011 1101 按位或
    A^B 0011 0001 异或
    ~B  1111 0010 非

    面试题：2*8 怎么算最快？ 2<<3
    <<左移  *2 效率极高！！
    >>右移  /2
   */
System.out.println(2<<3); // 16

三元运算符

int a = 10;int b = 20;a+=b; // a = a+ba-=b; // a = a-bSystem.out.println(a); //10//字符串连接符 + ，转化为String类型,然后拼接    注意！！System.out.println(""+a+b); //1020System.out.println(a+b+""); //30 先进行运算，再转为String拼接System.out.println(a+b+"str"); //30str

// x ? y : z//如果x为真，则结果为y,否则为z//if(x) y; else z;int score = 80;String type = score<60?"及格":"不及格";System.out.println(type); //及格

包机制

为了更好地组织类，Java提供了包机制，由于区分类名的命名空间
包的语法格式：

package pkg1[.pkg2[.pkg3...]];

一般利用公司域名倒置作为包名；com.kuangstudy.www
为了能够使用一个包的成员，需要在Java程序中导入该包

import package1[.package2...].(className|*); //通配符* 导入包下所有的类

参考：阿里巴巴Java开发手册

JavaDoc生成文档

javadoc命令是用来生成自己API文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明最早用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
API文档：https://docs.oracle.com/javase/8/docs/api/

/**
 * @author Kuangshen
 * @version 1.0
 * @since 1.8
 */
public class Demo05 {
    String name;

    /**
     * @author kuangshen
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
    
}

打开某个类所在文件夹下的cmd命令行
输入：javadoc -encoding UTF-8 -charset UTF-8 Doc(类名).java
会自动生成该类有关的API文档，查看文件夹发现多了一些文件
打开 index.html（首页）查看文档注释

Java流程控制

用户交互Scanner

Scanner对象

之前我们学的基本语法并没有实现程序和人的交互，Java给我们提供了一个工具类，可以获取用户的输入java.util.Scanner是Java5的新特征，我们通过Scanner类来获取用户的输入。
基本语法
```
Scanner s = new Scanner(System.in);
```

通过Scanner类的 next()与 nextLine()方法获取用户的字符串，读取前一般用hasNext()与hasNextLine()判断是否还有输入的数据。

//创建一个扫描器对象
Scanner scanner = new Scanner(System.in);

System.out.println("使用next方式接收");
//判断用户有没有输入字符串
if(scanner.hasNext()){  //使用hasNextLie()会接收一行 "hello word"
    //使用next方式接收
    String str = scanner.next(); 
    System.out.println("输入的内容为："+str);
    //input: hello word
    //输入的内容为：hello
}
//凡是属于IO流的类如果不关闭会一直占用资源
scanner.close();

next（）：

一定要读取到有效字符后结束输入
对输入有效字符之前遇到的空白，next（）方法会自动将其去掉
只有输入有效字符后才能将后面输入的空白作为分隔符或者结束符
next（）不能得到带有空格的字符串

Scanner scanner=new Scanner(System.in);
System.out.println("你输入的是：");
String str=scanner.nextLine();
System.out.println("输出："+str);
scanner.close();

nextLine():

以enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
可以获得空白

Scanner进阶

判断scanner是否输入的正确

Scanner scanner=new Scanner(System.in);
int i=0;
System.out.println("请输入整数:");
if (scanner.hasNextInt()){
    i = scanner.nextInt();
    System.out.println("你输入的没错:" + i);
}else{
    System.out.println("请输入整数");
}

Scanner sanner=new Scanner(System.in);
float a=0.0f;
System.out.println("请输入小数:");
if (scanner.hasNextFloat()){
    a = scanner.nextFloat();
    System.out.println("你输入的是小数没错:" + a);
}else{
    System.out.println("请输入小数");
}
scanner.claose();

例题：我们可以输入多个数字，并求其总和和平均数，每输入一个数字回车确认，通过输入非数字来结束输入并输出执行结果

 Scanner scanner=new Scanner(System.in);
float f=0.0f;
float sum=0.0f;
float avg=0.0f;
System.out.println("请输入多个数字：");
while (scanner.hasNextFloat()){
    f=scanner.nextFloat();
    sum=sum+f;
    avg++;
    System.out.println("你输入了第"+avg+"数字");
}
System.out.println("一共有"+avg+"个数字，"+"和为"+sum+"，平均数为："+sum/avg);
scanner.close();

switch选择结构

多选择结构还有一个实现方式就是switch case语句

switch语句中的变量类型可以是：

byte、short、int或者char
从Java SE7开始
switch支持字符串String类型了
同时case标签必须为字符串常量或字面量

char grade='C';
        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("再接再厉");
                break;
            default:
                System.out.println("未知等级");
        }

switch可以支持字符串

String str="world";
        switch (str){
            case "hello":
                System.out.println("你好");
                break;
            case "world":
                System.out.println("世界");
                break;
            default:
                System.out.println("java");
                break;
        }

循环结构

while循环

//计算1+2+3+...+100
int i=0;
int sum=0;
while(i<100){
    i++;
    sum+=i;
}
System.out.println(sum); //5050

do……while循环

//先执行后判断，至少执行一次
do{
    i++;
    sum+=i;
}while(i<100) //跟上面效果一样

for循环

//（初始化;条件判断;迭代）
for(int i=0;i<100;i++){
    i++;
    sum+=i;
}
for(; ; ){...} //死循环

九九乘法表

 for (int i=1;i<=9;i++){
            for (int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }

输出1-1000能被5整除的数，每行输出3个

//练习：输出1-1000能被5整除的数，每行输出3个for (int i = 1; i <= 1000; i++) {    if(i%5==0){        System.out.print(i+"\t"); //输出完不换行    }    if(i%(3*5)==0){        System.out.println();    }}

死循环

//（初始化;条件判断;迭代）for(int i=0;i<100;i++){    i++;    sum+=i;}for(; ; ){...} //死循环

break & continue

break可用在任何循环的主体部分，由于强行退出循环，也可以用在switch语句。
continue用于循环语句中，终止某次循环过程，跳过剩余语句，之间进行下一次循环条件判断。
标签：后面跟一个冒号的标识符 label：

增强for循环

 int []num={10,12,45,31,2,12};        for (int i=0;i<6;i++){            System.out.println(num[i]);        }        System.out.println("===================");        for (int x: num){            System.out.println(x);        }

增强for循环可以进行简写，简单方法：如果要循环5次，可以“5.for”就可以在idea中使用

打印三角形

 for (int i = 0; i < 6; i++) {            for (int j=5;j>i;j--){                System.out.print(" ");            }            for (int j=1;j<=i;j++){                System.out.print("*");            }            for (int j=1;j<i;j++){                System.out.print("*");            }            System.out.println();        }

Java方法详解

Java方法是语句的集合，他们在一起执行一个功能。

方法是解决一类问题的步骤的有序结合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

设计方法的原则：方法的本意是代码块，就是实现某个功能的语句块。我们设计方法的时候，最好保持方法的原子行，就是一个方法只完成1个功能，这样利于我们后期的扩展。

方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一班情况下，定义一个方法包含以下语法：

方法包含一个方法头和一个方法体。下面是一个方法的所有部分
- 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法，定义了该方法的询问类型
- 返回值类型：方法可能会返回值，returnValueType是返回值的数据类型，有些方法执行所需的操作，但没有返回值，在这种情况下，returnValueType是关键字void
- 方法名：是方法的实际名称、方法名和参数共同构成方法签名
- 参数类型参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或者变量，参数列表是指方法的参数类型、顺序和参数的个数，参数是可选的，方法可以不包含任何参数
```
//main方法
    public static void main(String[] args) {
        
        //实际参数：实际调用传递给他的参数
        int sum=add(5,5);
        
        System.out.println(sum);
    }

    //加法
    //形式参数，用来定义作用的
    public static int add(int a,int b){
        return a+b;
    }
```
- 方法体：方法体包含具体的语句定义该方法的功能
```
修饰符 返回值类型（void不返回） 方法名（参数类型 参数名）{
		···
  	方法体
    ···
    return 返回值;
}
```
Java是值传递

方法的重载

重载就是在一类中，有相同的函数名称，但形参不同的函数
方法的重载的规则
- 方法名称必须相同
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
- 方法的返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载
实现理论：

方法名称相同时，编译器会根据调用方法的参数个数、参数类型去逐个匹配，已选择对应的方法，如果匹配失败，则编译器报错

命令行传参

有时候希望运行一个程序时再传递给它消息。这要靠传递命令行参数给main（）函数实现

public static void main(String[] args) {    //args.length 数组长度    for (int i = 0; i < args.length; i++) {        System.out.println("args["+i+"]: "+args[i]);    }}

找到当前类的文件夹，打开cmd

可变参数

Jdk1.5开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号 (…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。

public static void main(String[] args) {
  //调用可变参数的方法
        printmax(34,45,456,4,6545,44,54,4,54);
        printmax(new double[]{1,2,3});
   }
   public static void printmax(double ...numbers){
       if (numbers.length==0){
           System.out.println("No argument passed");
           return;
       }

       double result=numbers[0];

       //找最大值
       for (int i=1;i<numbers.length;i++){
           if (numbers[i]>result){
               result=numbers[i];
           }
       }
       System.out.println("The max value is "+result);
   }

计算器的实现

public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入第一个数值:");
        while (scanner.hasNextDouble()){
            double a=scanner.nextDouble();
            System.out.println("请输入操作符");
            String str=scanner.next();
            System.out.println("请输入第二个数值：");
            double b=scanner.nextDouble();
            switch (str){
                case "+":
                    add(a,b);
                    break;
                case "-":
                    mius(a,b);
                    break;
                case "*":
                    multiply(a,b);
                    break;
                case "/":
                    except(a,b);
                    break;
                default:
                    System.out.println("输入的运算符错误");
                    break;
            }
        }
        }
        public static void add(double num1,double num2){
            System.out.println(num1+num2);
        }
        public static void mius(double num1,double num2){
            System.out.println(num1-num2);
        }
        public static void multiply(double num1,double num2){
            System.out.println(num1*num2);
        }
        public static void  except(double num1,double num2){
            if (num2==0){
                System.out.println("分母不能为0");
            }else{
                System.out.println(num1/num2);
            }

        }

Java中的数组

数组的简单实现

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
```
datatype [] arrayRefVar;int [] num1;
```
Java语言使用new操作符来创建数组，语法如下：
```
datatype [] arrayRevVar=new dataType[arraySize];
```
数组的元素是通过索引访问的，数组索引从0开始

获取数组长度：array.length

 //变量的类型 变量的名字=变量的值；    //数组类型    public static void main(String[] args) {        int [] nums;//1.声明一个数组        nums=new int[10];//2.创建一个数组        int [] nums2=new int[10];//声明和创建可以放在一起        //3.给数组元素赋值        nums[0]=1;        nums[1]=2;        nums[2]=3;        nums[3]=4;        nums[4]=5;        nums[5]=6;        nums[6]=7;        nums[7]=8;        nums[8]=9;        nums[9]=10;        //计算所有元素的和        int sum=0;        for (int i = 0; i < nums.length; i++) {            sum+= nums[i];        }        System.out.println(sum);    }

数组的初始化

//静态初始化：创建+赋值int [] a={4,1,2,3,5,4,6,4};System.out.println(a[0]); //动态初始化 int [] b=new int[10]; b[0]=10; System.out.println(b[0]);

数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论原始类型还是其他对象类型，数组对象本身是在堆中。
ArrayIndexOutOfBoundsException：数组下标越界异常

数组使用

普通的for循环

int [] arrays={1,2,3,45,5};        int sum=0;        for (int i=0;i< arrays.length;i++){            sum+=arrays[i];            System.out.println(arrays[i]);        }

for—Each循环（增强for循环）

int [] arrays={1,2,3,45,5};       for (int ayyays:arrays){            System.out.println(ayyays);        }

数组做方法入参（void作为方法入参，可以没有返回值）

int [] arrays={1,2,3,45,5};printArray(arrays);   //打印数组元素    public static void printArray(int[] arrays){        for (int i=0;i< arrays.length;i++){            System.out.print(arrays[i]+" ");        }    }

数组作返回值（反转数组）

int [] arrays={1,2,3,45,5};int [] reverse= reverse(arrays);for (int i=0;i< reverse.length;i++){            System.out.println(reverse[i]);        }//反转数组    public static int[] reverse(int [] arrays){        int [] result=new int[arrays.length];        //反转操作        for (int i=0,j= result.length-1;i< arrays.length;i++,j--){            result[j]=arrays[i];        }        return result;    }

二维数组

二维数组的遍历

 int [] [] array={{3,4},{5,6},{6,7}};//        System.out.println(array[1][1]);        //遍历二维数组的长度        for (int i=0;i< array.length;i++){            for (int j=0;j

Arrays类

数组的工具类是java.utill,Arrays
由于数据对象本身并没有方法可以供我们使用，但是API提供了一个工具类Arrays供我们使用
Array类中的方法都是static修饰的静态方法，使用时直接使用类名进行调用，可以不用对象调用
常用功能
- 给数组赋值：fill方法
- 排序：sort方法，升序
- 比较数组：equals方法比较数组中元素值是否相等
- 查找数组元素：binarySearch对排序号的数组进行二分法查找操作

 int [] array={3,5,4,6,3,1,2,0,5,9,8,7};        //填充数组        Arrays.fill(array,2,4,0);        //打印数组        System.out.println(Arrays.toString(array));        //排序数组        Arrays.sort(array);        System.out.println(Arrays.toString(array));        //二分查找 返回的是值的下标        System.out.println(Arrays.binarySearch(array,0));

冒牌排序

冒泡排序是八大排序最出名的排序算法。
代码：两层循环，外层冒泡轮数，里层依次比较。
当我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)。

public static void main(String[] args) {        int [] a={4,5,6,5,45,54,5,64,54,7};        int [] sort=sort(a);        System.out.println(Arrays.toString(sort));    }    public static int [] sort(int []array){        int temp=0;        for (int i=0;i< array.length-1;i++){//            boolean flag=true;            for (int j=0;j< array.length-i-1;j++){                if (array[j+1]

加上“//”为优化部分

稀疏数组

//创建一个二维数组 11*11 0：没有妻子 1：黑子 2：白字
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        System.out.println("输出原始的数组");

        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        //转换为稀疏数组保存
        //1.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("=================");
        System.out.println("有效值的个数 " + sum);

        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //3.遍历二维数组，将非零的值，存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[i][j];
                }
            }
        }
        //4.输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t"
                    + array2[i][1] + "\t"
                    + array2[i][2] + "\t");
        }
        System.out.println("==============");
        System.out.println("还原");
        //1.读取稀疏数组
        int [][]array3=new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原他的值
        for (int i=1;i< array2.length;i++){//注意从1开始，0是头部信息
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }

        //3.打印
        System.out.println("输出还原的数组");

        for (int [] ints:array3){
            for (int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }

面向对象编程（OOP）

初始面向对象

属性+方法=类
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
面现象对象比那晨光的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
从认识论角度考虑是现有对象后有类。

回顾方法的定义以及调用

定义

main方法

 //main 方法    public static void main(String[] args) {    }/*修饰符 返回值类型 方法名（……）{    //方法体    return 返回值；    } */    public String sayhello(){        return "hello world";    }    public void print(){        return;    }    public int max(int a,int b){        return a>b ?a :b;    }

方法的调用

Students students=new Students();students.say();

注意值传递和参数传递

	 public static void main(String[] args) {        Person person= new Person();        System.out.println(person.name);        Demo05.change(person);        System.out.println(person.name);    }    public static void change(Person person){        person.name="张三";    }    }class Person{    String name;//null

基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的
对象作为参数传递时，是对象在内存中的地址拷贝一份给了参数

类和对象的关系

类是一种冲向的数据类型，它是对某一类事务整体描述/定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例

创建和初始化对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的使用

//实例化对象Students xiaoming =new Students();        xiaoming.name="小明";        xiaoming.age=3;        System.out.println(xiaoming.name);        System.out.println(xiaoming.age);

//类public class Students {    //学生类    String name;//null    int age;//0    //方法    public void study(){        System.out.println(this.name+"在学习 ");    }}

一个类即使什么都不写，它也会存在一个方法
构造器：
- 和类名相同
- 没有返回值
核心作用：
- 使用new关键字，本质是在调用构造器
- 构造器同来初始化值
在无参构造器中，无参构造器可以实例化初始值

//无参构造器public Person（）{  }//在main方法中Person person=new Person();

注意点：

有参构造器：一旦定义了有参构造，无参就必须显示定义
Alt+Insert

内存分析

  //类：抽象的，实例化        //类实例化会返回一个自己的对象        //student对象就是一个Students类的具体实例        Students xiaoming =new Students();        xiaoming.name="小明";        xiaoming.age=3;        xiaoming.study();        xiaoming.play();        System.out.println(xiaoming.name);        System.out.println(xiaoming.age);        Students xiaohong=new Students();        xiaohong.name="小红";        xiaohong.age=15;        xiaohong.study();        System.out.println(xiaohong.name);        System.out.println(xiaohong.age);

 //学生类    String name;//null    int age;//0    //方法    public void study(){        System.out.println(this.name+"在学习 ");    }    public void play(){        System.out.println(this.name+"在游戏中，王者荣耀");    }

对象通过引用类型来操作：栈 - - ->堆

小结类与对象

类与对象
- 类是一个模板：抽象，对象是一个具体的实例
方法
- 定义，通用！
对应的引用
- 引用类型：基本类型（8）
- 对象是通过引用来操作的：栈—→堆
属性：字段Field 成员变量
- 默认初始化：
  - 数字：0 0.0
  - char u0000
  - boolean：false
  - 引用：null
- 修饰符属性类型属性名=属性值！
对象的创建和使用
- 必须使用new关键字创建对象，构造器Person xiaohong=new Person（）；
- 对象的属性 xiaohong.name
- 对象的方法 xiaohong.sleep()
类
- 静态的属性属性
- 动态的行为方法

封装

该露的露，该藏的藏
- 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏。
属性私有，get/set

 		//名字
    private String name;

    //学号
    private int id;

    //性别
    private char sex;

    //年龄
    private int age;

    public int getAge() {
        if (age>120 || age<0){
            this.age=3;
        }else{
            this.age=age;
        }
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

 Students s1=new Students();        s1.setAge(1200);        System.out.println(s1.getAge());

作用
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加了

继承

继承的本质是对某一批类的抽象，从而实现对世界更好的建模
extends的意思是“扩展”。子类是父类的扩展，使用extends来表示
Java中只有单继承，没有多继承！一个类是能继承一个父类
继承是类与类之间的一种关系，此外还有依赖、组合、聚合等
继承关系的两个类，一个是子类（派生类），一个是父类（基类）子类继承父类
子类继承了父类，就会拥有父类的全部方法，而private私有属性及方法无法继承。
在Java中，所有类，都默认直接或间接继承Object类 (Ctrl+H 可以查看类关系)
被final修饰的类，无法被继承（断子绝孙）。

super&this

super注意点：

super调用父类的构造方法，必须在构造方法的第一个（默认调用）
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法

VS this

代表的对象不同：
- this：本身调用者这个对象
- super：代表父类对象的应用
前提
- this：没有继承也可以使用
- super：只能在继承条件下可以使用
构造方法
- this（）：本类的构造
- super（）：父类的构造
super与this的区别：super代表父类对象的引用，只能在继承条件下使用；this调用自身对象，没有继承也可以使用。

super(); //隐藏代码，默认调用了父类的无参构造，要写只能写第一行

方法的重写

重写：子类的方法必须与父类方法必须一致，方法体不同。
参数列表必须相同
修饰符可以扩大但是不可以缩小
- public>protected>default>private
抛出的异常：范围，可以被缩小，但是不能扩大：ClassNotFoundException–>Exception（大）
重写是方法的重写，与属性无关
重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）
被**static(属于类，不属于实例)，final(常量方法)，private(私有)**修饰的方法不能重写

public class B {
    public static void test(){ //静态方法
        System.out.println("B==>test()");
    }
}

public class A extends B{ //继承
    public static void test(){
        System.out.println("A==>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的调用之和左边定义的类型有关
        A a = new A();
        a.test(); //打印 A==>test()

        //父类的引用指向了子类，但静态方法没有被重写
        B b = new A();
        b.test(); //打印 B==>test()
    }
}

修改A.Java，B.java

public class B {    public void test(){ //非静态方法        System.out.println("B==>test()");    }}public class A extends B{    @Override //重写了B的方法    public void test() {        System.out.println("A==>test()");    }}

//父类的引用指向了子类B b = new A(); //子类重写了父类的方法，执行子类的方法b.test(); //打印变成了 A==>test()/* 静态方法是类的方法，非静态方法是对象的方法有static时，b调用了B类的方法，因为b是b类定义的没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法*/

重写：子类的方法必须和父类保持一致：方法体不同

被**static(属于类，不属于实例)，final(常量方法)，private(私有)**修饰的方法不能重写

为什么重写：

父类的功能，子类不一定需要，或者不一定满足

多态

即同一方法可以根据发送对象的不同而采用不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用可以有很多
多态存在条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e0qkJ1Og-1633573131035)(C:\Users\jameslzhang\AppData\Roaming\Typora\typora-user-images\image-20211003093902789.png)]