狂神说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;

//布尔值：是非
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 double PI=3.14;	//类变量，该类下的全局范围

变量的命名规范

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

运算符

在这里插入图片描述

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


//幂运算 2^3 2*2*2=8 double 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
! 取反，真变为假，假变为真

//与(and)或(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+b; 
System.out.println(a);
//字符串连接符 + ，转化为String类型,然后拼接   注意！
System.out.println(""+a+b);  //1020
System.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/

/**
*@auther kuangshen
*@version 1.0
*@since 1.8
*/
public class Demo05{
    String name;
    
    /**
    *@auther 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()){	//使用hasNextline()会接收一行"hello world"
    //使用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.cloase();

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 scanner = 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.close();

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

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 += 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();
    }
}

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方法
pubilc static void main(String[] args){
    
    //实际参数：实际调用传递给他的参数
    int sum=add(5,5);
    
    System.out.println(sum);
}

//加法
//形式参数，用来定义作用的
public static int add()

方法体：方法体包含具体的语句定义该方法的功能

修饰符 返回值类型（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 srt = 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{
        Syste.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)
}

数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可改变的
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，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 array:arrays){
    System.out.println(array);
}

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

int[] arrays={1,2,3,45,5};
printArray(arrays);

//打印数组元素
public static void printArray(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<array[i].length,j++){
        System.out.println(array[i][j]);
    }
}

Arrays类

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

int[] array={3,4,5,6,7,2,1,0,8,9,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){
    //        1.比较数组中，两个相邻的元素，如果第一个比第二个大，我们就交换他们的位置
        //        2.每一次比较，都会产生一个最大或最小的数字
        //        3.下一轮，则可以少一次排序
        //        4.依次循环，直到结束
    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=false;
        //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
        for(j=0;j<array.length-1-i;j++){
            if(array[j]>array[j+1]){
                //如果第一个数大于第二个数，第二个数放前，第一个数放后
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                flag = true;
            }
        }
        if(flag==false){
            break
        }
    }
    return array;
}

稀疏数组

在这里插入图片描述

//创建一个二维数组 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(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.ptintln("还原");
//1.读取稀疏数组
int[][] array3=new int[array2[0][0]][array[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;
}

break：跳出switch循环，结束循环。continue：结束依次循环。return：方法结束，返回类型和返回值相同。

方法名：见名知意，驼峰命名法。参数列表：（参数类型，参数名），...可变参数，数组运用可变参数。

静态方法：

public static void say(){
    system.out.print("1111");
}//可直接通过方法名调用，和类一起加载。

非静态方法

public void say(){
    System.out.print("1111");
}
//调用
Student student = new Student();//实例化这个类new，对象类型 对象名=对象值;
student.say();

形参

public static int add(int a,int b){//int a,int b,形参
	return a+b;    
}

实参

public static void main(String[] args){
    int add = Demo03.add(1,3);//1,3:实参
    System.out.println(add);
}

值传递

//值传递
public class Demo04{
   public static void main(String[] args){
       int a=1;
       System.out.println(a);
       
       Demo04.change(a);
       System.out.println(a);
   }
    
    //返回值为空
    public static void change(int a){
        a=10;
    }
}

a=10，返回值为空，a的值还为1。

引用传递

//引用传递：对象，本质还是值传递
public class Demo05{
    public static void main(String[] args){
        Person person = new Person();
        
        System.out.println(person.name);//null
        
        Demo05.change(person);
        
        System.out.println(person,name);//test
    }
    public static void change(Person person){
        //person是一个对象：指向的--->Person person=new Person();这是一个具体的人，可以改变属性
        person.name = "test";
    };
}


//定义了一个Person类，有一个属性：name
class Person{
    String name;//null
}

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

类和对象的关系

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

创建和初始化对象

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

1595485938430

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

1595486615687

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

内存分析

1595487183165

在这里插入图片描述

小结类与对象

1.类与对象

类是一个模板：抽象，对象是一个具体的实例

2.方法

定义，通用

3.对应的引用

引用类型：基本类型（8）

对象是通过引用来操作的：栈--->堆

4.属性：字段Field成员变量

默认初始化：

数字：0 0.0

char：u0000

boolean：false

引用：null

修饰符属性类型属性名=属性值;

5.对象的创建和使用

必须使用new关键字创建对象，构造器Person xiaoming=new Perosn();

对象的属性 xiaoming.name

对象的方法 xiaoming.sleep()

6.类

静态的属性属性

动态的行为方法

封装

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

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

继承

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

super&this

super注意点：

1.super调用父类的构造方法，必须在构造方法的第一个（默认调用）

2.super必须只能出现在子类的方法或者构造方法中

3.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(私有)修饰的方法不能重写

为什么重写：

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

Alt + Insert ; override;

多态

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

1595932129829

注意点

多态是方法的多态，没有属性的多态
1. 父类和子类，有联系类型转换溢出：ClassCastException
2. 存在条件：继承关系，方法需要重写，父类引用指向了子类对象

instanceof和类型转换

instanceof引用类型比较，判断一个对象是什么类型

1595939583793

类型转换
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型，会丢失自己原来的一些方法
- 把父类转换为子类，向下转型，强制转换，才调用子类方法
- 方便方法的调用（转型），减少重复的代码，简洁

static

静态变量可以直接用类名访问，也称类变量
静态变量（或方法）对于类，所有对象（实例）共享
静态变量可以直接调用，但是非静态变量不可以直接调用

private static int age;
private double score;
public void run(){	}
public static void go(){	}

public static void main(String[] args){
    Student s1 = new Student();
    System.out.println(Student.age);
    System.out.println(Student.score);
    System.out.println(s1.ahe);
    System.out.println(s1.score);
    go();
    run();
}

静态区代码加载类时一起被初始化，最早执行且只执行一次（第一次new）

public class Person{
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法");
    }
    public static void main(String[] args){
        Person person = new Person();
        System.out.println("=====================")
        Person person2 = new Person();
        System.out.println("=====================")
        Person person3 = new Person();
    }
}

Math->随机数:

//静态导入包
import static java.lang.Math.random;
public class Application {    
    public static void main(String[] args) {        
        //第一种随机数，不用导包        
        System.out.println(Math.random()); 
        //0.7562202902634543        
        //第二种随机数，静态导入包        
        System.out.println(random()); 
        //0.5391606223844663    
    }
}

抽象类

abstract修饰的类就是抽象类，修饰的方法就是抽象方法
抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类
抽象类不能使用new来创建对象，它是用来让子类继承的
抽象方法只有方法的声明，没有实现，让其子类实现
子类继承抽象类，必须实现抽象类的所有方法，否则该子类也要声明为抽象类

1596091374081

1596091427354

编译器给抽象类添加了一个无参构造方法。

接口

接口最能体现OOP的精髓，对对象的抽象

在Java编程语言中是一个抽象类型，是抽象对象的集合，对象通常以interface关键字来声明。

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）共存
接口：只有规范，无法自己实现
- 约束和实现分离->面向接口编程

接口就是规范，定义一组规则，它的本质是契约，制定好之后大家都要遵守。

声明

[可见度] interface 接口名称 [extends 其他的接口名] {       
    // 声明变量  
    
    // 抽象方法 
}

/**
*用户接口，需要实现类
*锻炼抽象的思维
*/
public interface UserService{
    //定义的属性默认是静态常量：public static final
    int age = 10;
    
    //定义的方法是公共抽象：public abstract
    void add(String str);
    void delete(String str);
    void update(String str);
    void query(String str);
}

public interface TimeService{
    void timer();
}

特性

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字
接口中的方法都是公有的。

实现

/*
抽象类用继承：extends
接口用实现：implements
类可以实现接口，需要实现所有方法！
利用接口实现伪多继承~
*/
public class UserServiceImplement implements UserService,TimeService{
    @Override
    public void add(String str){
        
    }
    
    @Override
    public void delete(String str){
        
    }
    
    @Override
    public void update(String str){
        
    }
    
    @Override
    public void query(String str){
        
    }
    
    @Override
    public void timer(){
        
    }
}

类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常

在实现接口的时候，也要注意一些规则：

一个类只能继承一个类，但是能实现多个接口
一个接口能继承另一个接口，这和类之间的继承比较相似

继承

接口的继承使用extends关键字，子接口继承父类接口的方法

//文件名：Sports.java
public interface Sports{
    public void setHomeTeam(String name);
    public void setVisitingTeam(String name);
}

//文件名：Football.java
public interface Foorball extends Sports{
    public void homeTeamScored(int points);
    public void visitingTeamScored(int points)
    public void endOfQuarter(int quarter);
}

//文件名：Hockey.java
public interface Hockey extends Sports{
    public void homeGoalScored();
    public void visitingGoalScored();
    public void endOfPeriod(int period);
    public void overtimePeriod(int ot);
}

多继承

类不允许多继承
接口允许多继承

public interface Hockey extends Sports,Event

1596094615952

接口与类相似，一个接口可以有多个方法

接口与类的区别

接口不能被实例化
接口没有构造方法
接口中所有的方法必须是抽象方法
接口不能包含成员变量，除了static和final变量
接口不是被类继承，而是被类实现
接口支持多继承（实现类（implements）可以实现多个接口）
实现类必须要重写接口中的方法

1596094313451

JDK8之后的新特性，支持在接口中实现具体方法，但需要default修饰。default修饰方法只能在接口中使用。

内部类

内部类：在一个类的内部再定义一个类

class A{
    class B{
        
    }
}

A是B的外部类，B是A的内部类。

成员内部类

public class Outer{
    private int id;
    public void out(){
        System.out.println("外部类的方法");
    }
    
    //成员内部类
    public class Inner{
        public void inner(){
            System.out.println("内部类的方法");
        }
        
        //可以直接使用外部类的属性/方法
        public void getOuterId(){
            System.out.println("内部类调用外部类属性和方法");
            //创建成员内部类之前肯定要创建外部类对象
            //即使id不是静态变量，out不是静态方法，但创建外部类对象时已经存在。
            System.out.pirntln(id);
            out();
        }
    }
}

匿名内部类

public class Application{
    public static void main(String[] args){
        //匿名内部类在多线程中使用，到时候再深究
        Thread thread = new Thread(new Runnable(){
            @Override
            public void run(){
                System.out.println("匿名内部类实现线程的逻辑操作");
            }
        });
        //开启操作
        thread.start();
    }
}

异常

Java把溢出当做对象来处理，并定义了一个基类Java.lang.Throwable作为所有异常的超类。

Java语言定义了许多异常类在Java.lang标准包中，主要分为Error和Exception两大类。

在这里插入图片描述

五个关键字try、catch、finally、throw、throws

使用try和catch关键字可以捕获异常。try/catch代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码。

finally区可以不要，在IO流，资源关闭时使用。

捕获多个溢出：从小到大！

IDEA快捷键：选中健康区域代码-->Ctrl + Alt + T

public static void main(String[] args) {
        int a=1;
        int b=0;


        try{
            System.out.println(a/b);
        }catch (Error e){
            System.out.println("Error");
        }catch(Exception e){
            System.out.println("Exception");
        }catch (Throwable t){
            System.out.println("Throwable");
        }finally {
            System.out.println("finally");
        }
    }
    public void a(){b();}
    public void b(){a();}

抛出异常

throws是用来声明一个方法可能抛出的所有异常信息，throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。而throw则是指抛出的一个具体的异常类型

throws是用在方法名尾部，可以声明抛出多个溢出，多个溢出之间用逗号隔开。

import java.io.*;
public class className{
    public void withdraw(double amount) throws RemoteException,InsufficientFundsException{
        //Method implementation
    }
    //Remainder of class definition
}

throw是用在方法体内，主动抛出异常

public class ThrowTest{
    public static void main(String[] args){
        int a = 1;
        int b = 0;
        
        try{
            System.out.println(divide(a,b));
        }catch (Exception e){
            System.out.println("分母不能为0");
            //e.printStackTrace();
        }
    }
    
    public static double divide(int a,int b){
        if(b == 0){
            //主动抛出异常
            throw new ArithmeticException();
        }
        return 1.0*a/b;
    }
}

自定义异常

在这里插入图片描述

//自定义的异常类
public class MyException extends Exception{
    private int detail;
    
    public Myexception(int a){
        this.detail = a;
    }
    
    //异常的处理信息
    //tostring
    @Override
    public String toString(){
        return "Myexception{" + "detail=" + detail + "}";
    }
}

public class Appcication{
    //可能存在异常方法
    static void test(int a) throws MyException{
        System.out.println("传递的参数为：" + a);
        if(a>10){
            throw new MyException(a);//抛出
        }
        System.out.println("ok");
    }
}

public static void main(String[] args){
    try{
        test(11);
    }catch (MyException e){
        System.out.println("MyException=>" + e);
    }
}

总结

处理运行是异常时，采用逻辑去合理规避，同时辅助try-catch处理
在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
对于不确定的代码，也可以加上try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
具体如何处理异常，要根据不同的业务需求和异常类型去决定
尽量添加finally语句块去释放占用的资源。

转载：https://blog.csdn.net/qq_42186847/article/details/120633189

https://www.cnblogs.com/gdf456/p/13836944.html#_label16_2

posted @ 2022-01-09 22:18 小曺阅读(2157) 评论(0) 编辑收藏举报

刷新页面返回顶部

小曹

不忘初心，方得始终

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

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

预科

什么是计算机

硬件及冯诺依曼结构

计算机硬件

冯诺依曼结构

软件及软件开发

计算机软件

Windows常用快捷键

基本的Dos命令

计算机语言发展史

高级语言

Java入门

Java帝国的诞生

Java特性与优势

Java三大版本

JDK JRE JVM

安装开发环境

卸载JDk

安装JDK

Java基础

注释

标识符和关键字

关键字

标识符注意点

数据类型

类型转换

变量、常量、作用域

变量作用域

常量

变量的命名规范

运算符

逻辑运算符

位运算

三元运算符

包机制

JavaDoc生成文档

Java流程控制

用户交互Scanner

Scanner对象

Scanner进阶

switch选择结构

循环结构

Java方法详解

方法的定义

方法的重载

命令行传参

可变参数

计算器的实现

Java中的数组

数组的简单实现

数组的四个基本特点

数组使用

二维数组

Arrays类

冒泡排序

稀疏数组

面向对象编程（OOP）

初识面向对象

回顾方法的定义以及调用

定义

类和对象的关系

创建和初始化对象

内存分析

小结类与对象

封装

继承

super&this

方法的重写

多态

instanceof和类型转换

static

抽象类

接口

内部类

异常

公告