狂神说javaSE基础知识

最新推荐文章于 2022-10-09 13:18:05 发布
最新推荐文章于 2022-10-09 13:18:05 发布
阅读量587 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Promise_Blue/article/details/123536671
版权

即使再小的帆也能远航！

自己选择的路跪着也要走完！

img

1、博客（学习准备）

1.1、什么是博客？

博客，英文名为Blog，它的正式名称为网络日记

1.2、为什么要写博客？

  • 需要总结和思考。有时候我们一直在赶路，缺忘了放慢脚步
  • 提升文笔组织能力
  • 提升学习总结能力
  • 提升逻辑思维能力
  • 帮助他人，结交朋友

1.3、道理

冰冻三尺非一日之寒，写博客也是，短期内可能看不到效果，但是长期坚持，对自己的提升很有帮助。

1.4、博客分为哪几种？

  • 博客园
  • CSDN
  • 简书
  • 知乎
  • …

1.5、快捷键

alt + F4 -->关闭程序

ctrl + shif + ESC -->任务管理器

1.6、Dos命令

1.6.1、打开CMD的方式

  1. 开始+系统+命令提示符
  2. Win键+R 输入cmd打开控制台（推荐使用）
  3. 在任意文件夹下面，按住shif键+鼠标右键点击，在此处打开命令行窗口
  4. 资源管理器的地址栏上面加上cmd路径

管理员方式运行：选择以管理员方式运行

1.6.2、常用的Dos命令

#盘符切换
进入D盘：输入D:
#查看当前目录下的所有文件   dir
##切换目录   cd change directory
cd .. 返回上级目录
#清理屏幕 cls （clear screen）
#退出终端 exit
#查看电脑的ip ipconfig

#打开应用
	calc 计算机
	mspaint 绘图
	notepad 记事本

#ping 命令
	ping www.baidu.com
#文件操作
	md 目录名
	rd 目录名
	cd> 文件名
	del 文件名

2、Java帝国的诞生

三高：高可用，高性能，高并发

2.1、java特性和优势

  • 简单性
  • 面向对象
  • 可移植性：写一次，导出运行！
  • 高性能
  • 分布式
  • 动态性
  • 多线程
  • 安全性
  • 健壮性

2.2、java三大版本

  • Write Once,Run Anywhere JVM

  • JavaSE:标准版（桌面程序，控制台开发）

  • JavaME:嵌入式开发（手机，小家电）

  • JavaEE:E企业级开发（web端，服务器开发…）

2.3、JDK、JRE、JVM

  • JDK: Java Development Kit
  • JRE: Java Runtime Environment
  • JVM:Java Virtual Machine

2.4、java环境的搭建

2.4.1、 卸载

  1. 删除安装目录

  2. 删除环境变量JAVA_HOME

  3. 删除PATH中关于java的

  4. 使用cmd查看java -version

2.4.2、 jdk8下载安装

  1. 百度搜索jdk8，找到下载地址；同意协议；下载电脑对应的版本；双击安装jdk；记住安装的路径：配置环境变量； 打开配置的步骤： 右键此电脑+属性+高级系统设置 在系统变量配置

  2. 配置环境变量 JAVA_HOME D:\Java\jdk1.8.0_261

  3. 配置path变量 %JAVA_HOME%\bin %JAVA_HOME%\jre\bin

  4. 测试JDK是否安装成功

    1. 打开cmd
    2. java -version 注意里面有个空格

notepad++ 下载下来

2.5、HelloWorld

  1. 随便新建一个文件夹，存放代码
  2. 新建一个java文件
    • 文件后缀名为.java
    • Hello.java
    • 【注意点】系统可能没有显示文件后缀名，我们需要手动打开
  3. 编写代码
public class Hello{
    public static void main(String[] args){
        System.out.print("Hello,World!");
    }
}

  1. 编译javac java文件，会生成一个class文件

  2. 运行class文件，java class文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9x4tWMji-1647436554826)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20211125211247186.png)]

可能会遇到的情况：

  1. 每个单词的大小写不能出现问题，java是大小写敏感的
  2. 尽量使用英文 中文有的可能出错
  3. 文件名和类名必须保证一致，并且首字母大写
  4. 符号使用英文状态下的 中文状态下的分号也会出错

2.6、java程序运行机制

  • 编译型（compile）：就相当于把英文全部变成中文，一次性完成，好处就是，效率高，缺点是，如果有这本书更新了，还需要重新翻译

  • 解释性：就相当于一个翻译官，你想看那一部分，就翻译哪一部分，还可以回去看之前的，好处就是，如果这本书更新了，不怎么影响，因为翻译管随时在，随时翻译，缺点是，整体下来，效率太低了

  • 程序运行机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zjcQqjov-1647436554827)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20211125212600375.png)]

总结：

我们一旦有了需求有了目标，剩下的道路就不断完善他而已，只要确定了方向，只要不停下脚步，我们终究能够抵达自己的终点

3、java语法基础

3.1、注释，标识符，关键字

3.1.1、注释

书写注释是一个非常好的习惯！！

单行注释：//

多行注释：*/* 注释 /

文档注释：JavaDoc /** 回车 就会出现：/** 文档 */

书写注释是个非常好的习惯

3.1.2、标识符

关键字：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vdjBbY5g-1647436554828)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220307174430307.png)]

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

标识符注意点：

  • 所有的标识符都应该以字母（A-Z或者a-z），美元符（$）,或者下划线（_）开始
  • 首字符之后可以是字母（A-Z或者a-z），美元符（$）,或者下划线（_）或者数字的任何字符组合
  • 不能使用关键字作为变量或方法名
  • 标识符是大小写敏感的
  • 合法标识符举例：age，$salary, _value , __1_value
  • 非法标识符举例：123abc， -salary ，#ava

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J4IggpSz-1647436554832)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220307175031926.png)]

  • 可以使用中文命名，但是一般不建议这样去使用 ，也不建议使用拼音，很low

3.2、数据类型

  • 强类型语言

    所有类型必须先定义后才能使用！

  • 弱类型语言

​ JS

  • Java的数据类型分为两大类：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WZ1OYKCw-1647436554832)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220307180136693.png)]

注意：一个字节八位

整数：

​ int 21亿 定义long的时候，为了知道是long 在数字后面加一个L

**小数：**浮点数

定义float的时候，在数字后面加一个F

字符：

就是单纯的一个字母或一个字

字符串：

String不是关键字，是个类

布尔值：是非

默认为false， 另一个值为：true

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pnRxNoqn-1647436554833)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220307205453008.png)]

二进制：0b

十进制

八进制：0

十六进制：0x 0~9 A~F

最好完全使用浮点数进行比较！

最好完全使用浮点数进行比较！

最好完全使用浮点数进行比较！

银行业务怎么表示：BigDecimal

转义字符：

\t 制表符

\n 换行符

布尔值扩展：

boolean flag = true; //新手

if(flag==true){} //老手

if(flag) 这两个是一样的

代码要精简易读

3.3、类型转换

低-------------------------------------------------------------->高

byte，short,char–>int–>long–>float–>double

运算中，不同类型的数据先转换为同一类型，然后进行运算

  • 强制类型装换：高—>低 需要在高的数值前面加个括号（低）
  • 自动类型转换：低---->高

注意点：

  1. 不能对布尔值进行转换
  2. 不能不对象类型装换为不相干的类型
  3. 在把高容量转换到低容量的时候看，强制转换
  4. 转换的 时候可能存在内存溢出，或者精度问题！
  5. 操作比较大的数的时候，注意溢出问题

3.4、变量，常量

3.4.1、变量

变量的作用域：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VdCUk5Cm-1647436554834)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20211128150703969.png)]

局部变量：是在方法内的

注意事项：

  • 每个变量都有类型，类型可以是基本数据类型，也可以是引用数据类型
  • 变量名必须是合法的标识符
  • 变量声明是一条完整的语句，因此每一个声明必须以分号结束

变量的命名规范：

  • 所有的变量，方法，类名:见名知意
  • 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写
  • 局部变量:首字母小写和驼峰原则
  • 常量：大写字母和下划线：MAX_VALUE
  • 类名：首字母大写和驼峰原则：Man，GoodMan
  • 方法名：首字母小写和驼峰原则：run(),runRun()

3.4.2、常量：

final 常量名=值;

final double PI = 3.14;

常量名用大写表示

3.5、运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X1qKMWBy-1647436554834)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220309151752536.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4y4A0TLi-1647436554835)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20211128195600888.png)]

异或运算：A^B 相同就是零，不相同就是1

三元运算符：

int score = 50;

String type = score <60 ? “不及格” : “及格”；

优先级：

3.6、包机制，JavaDoc

3.6.1、包机制

一般利用公司名倒置作为包名：com.kuangstudy.blog

import com.kuang.base.* 导入这个包下所有的类！！

看下阿里巴巴开发手册

3.6.2、javaDoc

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WmFr7aYi-1647436554835)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220309163037814.png)]

这是一个问题！！，，以后解决

4、java流程控制

4.1、用户交互Scanner

java.util.Scanner 是一个工具包 可以通过Scanner类来获取用户的 输入

基本语法：

Scanner s = new Sanner(System.in);

  • 通过Scanner类的**next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()**判断是否还有输入的数据

  • next（）

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

  • nextLine():

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

4.2、顺序结构

java的基本结构

4.3、选择结构

if（）{

}

if（）{

}else{

}

if（）{

}else if（）{

}else if（）{

}else{

}

if（）{

​ if（）{

​ }

}

equals（）:判断字符串是否相等

switch多选择结构

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

  • switch语句中的类型变量可以是：
    • byte，short，int，char
    • 从javasE7开始 支持字符串String类型了
    • 同时case标签必须为字符串常量或字面量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KgMPjedK-1647436554835)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220310102225401.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9H1GAhPP-1647436554836)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220310102736829.png)]

4.4、循环结构

4.4.1、while(){

}

4.4.2、do{}while()

  • whilehe do-while的区别：
    • while先判断后执行，do-while是先执行后判断！
    • do-while总是保证循环体会被至少执行一次！这是他们的主要差别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rPxVpJN9-1647436554836)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220310112913992.png)]

4.4.3、for（初始化;布尔表达式;更新）{}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7FC7sqOV-1647436554836)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220310113740672.png)]

  • 关于for循环有一下几点说明：

    最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。

    然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环后面的语句

    执行一次循环体，更新循环控制变量（迭代因子控制循环变量的增减）

    在检测布尔表达式，循环执行上面的过程。

  • 增强for循环

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nk3hLQyX-1647436554837)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220310195930399.png)]

4.5、break&continue

  • break在任何循环语句的主题部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
  • continue语句在循环过程中，用于终止末次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

4.6、练习

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2IAbtmX0-1647436554837)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220310210456897.png)]

5、java方法

5.1、何谓方法

  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用

5.2、方法的定义及调用

java方法类似于其它语言的函数

  • 方法包含一个方法头和一个方法体

    • 修饰符：（可选）public

    • 返回值类型：可以有返回值，也可以没有返回值void

    • 方法名：首字母小写，遵循驼峰命名规范

    • 参数类型：实参：调用方法时实际传给方法的数据

      ​ 形参：在方法调用时用于接收外界输入的数据

    • 方法体；

修饰符 返回值类型 方法名（）{

​ …

​ 方法体

​ …

​ return 返回值;

}

  • 方法调用

调用方法：对象名.方法名（实参列表）

java支持两种调用方法的方式，根据方法是否返回值来支持：

1.当方法返回一个值的 时候，方法调用通常被当做一个值，例如：

​ int large = max（30,40）;

2.如果方法返回值是void，方法调用一定是一条语句

System.out.println(“Hello,kuangshen!”);

5.3、方法重载

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

5.4、命令行传参

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-08C0vxe5-1647436554837)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220311153711887.png)]

5.5、可变参数

  • 在方法声明中，在指定参数类型后加一个省略号（…）
  • 一个方法中只能指定一个可变参数，他必须是方法的最后一个参数。任何一个参数必须在它声明之前
image-20220311155231277

5.6、递归

A方法调用B方法，我们很容易理解

递归就是：A方法调用A方法，就是自己调用自己

递归结构包括两个部分：

​ 递归头：什么时候不调用自身的方法。如果没有头，将陷入死循环

​ 递归体：什么时候需要调用自身的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gwzg2ROh-1647436554838)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220311160810667.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rtUq5YlF-1647436554838)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220311161023344.png)]

package com.kuang.struct;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String isNext = "y";
        while (isNext.equals("y")){
        System.out.println("请输入第一位需要参与运算的数字：");
        int x = sc.nextInt();

        System.out.println("请输入第二位需要参与运算的数字：");
        int y = sc.nextInt();

        System.out.println("请输入(+,-,*,/)中参与运算的一个运算符：");
        String z = sc.next();

        switch (z) {
            case "+":
                System.out.println("计算结果为；" + add(x, y));
                break;
            case "-":
                System.out.println("计算结果为：" + subtract(x, y));
                break;
            case "*":
                System.out.println("计算结果为：" + multiply(x, y));
                break;
            case "/":
                System.out.println("计算结果为：" + divide(x, y));
                break;
            default:
                System.out.println("输入运算符有误！");
                break;
            }
            System.out.println("是否继续计算？(输入y继续，其他任意键结束)：");

            isNext = sc.next();
        }
        System.out.println("感谢使用本计算机！");
        sc.close();
    }

    //实现两个数相加
    public static int add(int a,int b){
        return a+b;
    }

    //实现两个数相减
    public static int subtract(int a,int b){
        return a-b;
    }

    //实现两个数相乘
    public static int multiply(int a,int b){
        return a*b;
    }

    //实现两个数相除
    public static int divide(int a,int b){
        if (b==0){
            System.out.println("除数不能为0");
            return 0;
        }
        return a/b;
    }
}

6、java数组

6.1、数组概述

数组是相同类型数据的有序集合

6.2、数组声明创建

  • 首先必须声明数组变量，才能在程序中使用数组。

变量的类型    变量的名字  =  变量的值;

数组类型
dataType[] arrayRefVar;//首选的方法
或
dataType arrayRefVar[];//效果相同，但不是首选方法
  • java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize];
  • 数组的员素是通过索引访问的，数组索引从0开始。
  • 获取数组长度： arrays.length

6.3、数组声明

image-20220311203954441 image-20220311204117396

  • 三种初始化

    • 静态初始化

      
创建+赋值
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,3)};

    • 动态初始化

      包含默认初始
int[] a = new int [2];
a[0] = 1;
a[1] = 2;

    • 数组的默认初始化

      • 数组是引用类型，他的元素相当于类的实例变量，一次数组一经分配空间，其中的每个元素也背按照实例变量同样的方式被隐式初始化

  • 数组的四个基本特点：

    • 其长度是确定的，数组一旦被创建，他的大小就是不可以改变的
    • 其元素必须是相同类型，不允许出现混合类型
    • 数组中的元素可以是任何数据类型，包括基本类型和引用类型
    • 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中队象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
image-20220312090251452 
package com.kuang.array;
public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //打印全部的数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("###########");
        //计算所有的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];
        }
        System.out.println(sum);

        System.out.println("###########");
        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i] > max){
                max = arrays[i];
            }
        }
        System.out.println(max);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-idrvXblk-1647436554839)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220312094556728.png)]

package com.kuang.array;
public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //jdk5  增强for循环
        //快捷键：arrays.for
        for (int array : arrays) {
            System.out.print(array+" ");
        }
        System.out.println("\n############");
        printArray(arrays);
        System.out.println("\n############");
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }
    //反转数组
    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;
    }
    //遍历数组的方法
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

6.4、多维数组

  • 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一位数组，器每一个元素都是一个一维数组

  • 二维数组

    int[][] a = new int[2][3];//动态二维数组
int[][] array = {{1,2},{3,4},{5,6},{7,8}};//静态二维数组

package com.kuang.array;
public class ArrayDemo03 {
    public static void main(String[] args) {
        /*
        1,2     array[0]
        3,4     array[1]
        5,6     array[3]
        7,8     array[3]
         */
        //打印二维数组
        int[][] array = {{1,2},{3,4},{5,6},{7,8}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

6.5、Arrays类

  • 数组的工具类java.util.Arrays
  • 由于数组对象本身并没有什么方法可以供我们使调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作
  • 查看jdk帮助文档
  • Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是不用而不是不能）
  • 具有以下常用功能
    • 给数组赋值：通过fill方法
    • 对数组排序：通过sort方法，按升序
    • 比较数组：通过equals方法比较数组中元素值是否相等。
    • 查找数组元素：通过binarySearch方法对排序好的数组进行排序进行二分法操作。
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,555,34,5,3,5,6,44,35};
        System.out.println(a);//[I@1540e19d
        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));

        //数组进行排序：升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //数组填充
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));//[1, 2, 0, 0, 4, 5, 5, 6, 34, 35, 44, 555]
    }
}

6.6、稀疏数组

  • 冒泡排序
  • 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序
  • 冒泡的代码还是相当简单的，两层循环，外层冒泡论述，里层依次比较，江湖中人人尽皆知
  • 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(2)
  • 如何优化？
package com.kuang.array;

import java.util.Arrays;

public class ArrayDemo05 {
    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每一次比较，都会产生一个最大，或者最小的数字
    //3.下一轮可以少一次排序
    //4.一次循环，直到结束！
    public static void main(String[] args) {
        int[] a = {1,4,5,3,2,5,7,1};
        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;//通过flag标识位减少没有意义的比较
            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] =temp;
                }
            }
            if (flag==false){
                break;
            }
        }
        return array;
    }
}

7、面向对象编程

7.1、初始面向对象

7.1.1、面向过程 & 面向对象

  • 面向过程思想
    • 步骤清晰，第一步做什么，第二步做什么…
    • 面对过程适合处理一些较为简单的问题
  • 面向对象思想
    • 物以类聚，分类的思维模式，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
    • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
  • 对于描述复杂的事物，为了在宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍需要面向过程的思想去处理。

7.1.2、什么是面向对象

  • 面向对象编程（Object-Oriented Programming,OOP）
  • 面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据
  • 抽象 就是抽一样的东西
  • 三大特性：
    • 封装 把它装进盒子里，然以留一个小口
    • 继承 儿子继承父亲的产业
    • 多态 一个人可以学习，但是多个人去学习，效果会不一样
  • 从认识论角度考虑是先有对象后有类。对象，是具体的事务。类，是抽象的，是对对象的抽象
  • 从代码运行角度考虑是先有类后有对象。类是对象的模板。

7.2、方法回顾和加深

  • 方法的定义：
    • 修饰符
    • 返回类型
    • break ：跳出switch，结束循环 和return ：结束一个方法，返回一个结果，可以什么都不返回 return；，可以返回任意一种类型 return 1；return “hello”;的区别
    • 方法名：注意规范就ok， 见名知意
    • 参数列表：（参数类型 参数名）…
    • 异常抛出:疑问，后面讲解
  • 方法的调用：
    • 静态方法
    • 非静态方法
    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zjy05399-1647436554839)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220312171825713.png)]
    • 形参和实参
    • 值传递和引用传递
    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4XN4GIwy-1647436554840)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220312172442463.png)]
    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U0zw1LVZ-1647436554840)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220312173618570.png)]
    • this关键字

7.3、对象的创建分析

  • 类与对象的关系：
    • 类是一种抽象的数据类型，他是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
    • 对象是抽象概念的具体实例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G6lRS9Cj-1647436554841)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220312175903847.png)]

  • 创建与初始化

    • 使用new关键字创建对象
    • 使用new关键字创建的时候，除了分配内存空间之外，还会 给创建好的对象进行默认的初始化以及对垒中构造器的调用
    • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有一下两个特点；
      • 1.必须和类的名字相同
      • 必须没有返回值类型，也不能写void
    • 构造器必须掌握

  • 构造器

    • 如果创建了有参构造器，，首先创建一个无参构造器，因为无参构造器是默认的，建立了有参，他会让默认的无参给顶掉，相当于没有无参构造器，new出来的对象，J就会报错

  • 作用：1.new 本质在调用构造方法 2.初始化对象的值

  • 注意点：1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dawbuSLG-1647436554841)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220313154422990.png)]

  • 内存分析：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IeOorQ9D-1647436554841)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220313173030491.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qBq0iZRZ-1647436554842)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220313172959570.png)]

  • 小结

    • 类与对象

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

    • 方法

      定义，调用！

    • 对应的引用

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

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

    • 属性；字段Filed 成员变量

      默认初始化：

      ​ 数字：0 0.0

      ​ char： u0000

      ​ boolean：false

      ​ 引用：null

      ​ 修饰符 属性类型 属性名 = 属性值！

    • 对象的创建和使用

      • 必须使用new关键字创造对象，构造器 Person kuangshen = new Person();
      • 对象的属性 kuangshen.name
      • 对象的方法 kuangshen.sleep();

    • 类：

      静态的属性 属性

      动态的行为 方法

7.4、面向对象的三大特性

7.4.1、封装性：

  • 该漏的漏，该藏的藏

    • 我们程序设计要追求“高内聚低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

  • 封装（数据的封装）

    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

  • 记住这句话就够了：属性私有，get/set

  • 提高程序的安全性，保护数据

  • 隐藏代码的实现细节

  • 统一接口

  • 系统可维护增加了

package com.oop;

import com.oop.demo03.Student;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setAge(121);
        System.out.println(s1.getAge());
    }
}


package com.oop.demo03;
public class Student {
    private String name;//名字
    private int age;//年龄
    private char sex;//性别
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age>120 || age<0 ){
            this.age = 3;
        }else {
            this.age = age;
        }
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
}

7.4.2、继承性：

  • 继承的本质是对某一批的抽象，从而实现对现实世界更好的建模
  • extends的意思是“扩展”。子类是父类的扩展
  • java中类只有单继承，没有多继承！
  • 继承是类和类之间的一关系。除此之外，类和类之间的关系还有依赖，组合，聚合等。
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
  • 子类和父类之间，从意义上讲应该具有“is a”的关系

ctr + h 在类里面随便点一个地方，就会出现类和类的关系

  • object类：

在java中，所有的类，都默认直接或者间接继承Object

  • super

super注意点：

	1. super调用父类的构造方法，必须在构造方法的第一个
	1. super必须只能出现在子类的方法或者构造器方法中！
	1. super和this不能同时调用构造方法

VS this；

  1. 代表的对象不同：
    • this：本身调用者这个对象
    • super：代表父类对象的应用
  2. 前提：
    • this：没有继承也可以使用
    • super：只能在继承条件下才可以使用
  3. 构造方法：
    • this（）：本类的构造
    • super（）：父类的构造
  • 方法重写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OqPHHlgd-1647436554842)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220316134937808.png)]

  • 重写：需要有继承关系，子类重写父类的方法！
    1. 方法名必须相同
    2. 参数列表必须相同
    3. 修饰符：范围可以扩大但不可以缩小： public>Protected>Default>private
    4. 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException ---->Exception(大)
  • 重写，子类的方法和父类必须一致：方法体不同！
  • 为什么需要重写：1.父类的功能，子类不一定需要，或者不一定满足！ alt + insert override重写

7.4.3、多态

image-20220316142143512
  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型很多
  • 多态存在的条件
    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象
  • 注意：多态是方法的多态，属性没有多态性
  • instanceof 类型转换
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G87GnyiV-1647436554842)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220316160255963.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-el9iDKUa-1647436554843)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220316160222280.png)]

多态注意事项：

  1. 多态是方法的多态，属性没有多态

  2. 父类和子类，有联系，类型转换异常！ClassCastException!

  3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new son();

  4. static 方法，属于类，他不属于实例

  5. final 常量；

  6. private方法

这三种没有办法实现重写，更不可能实现多态

  • static：
package com.oop.demo06;

public class Person {

    //2:在匿名代码块中可以赋初始值
    {
        System.out.println("匿名代码块");
    }
    //1：只执行一次~
    static {
        System.out.println("静态代码块");
    }
    //3:构造方法
    public Person(){
        System.out.println("构造方法");
    }
    
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("###################");
        Person person2 = new Person();
    }
    /*
    静态代码块
    匿名代码块
    构造方法
    ###################
    匿名代码块
    构造方法
     */
}

7.5、抽象类和接口

7.5.1、抽象abstract

package com.oop.demo07;

//abstract 抽象类：类 extends ：  单继承    （接口可以多继承）
public abstract class Action {

    //约束~有人帮我们实现
    //abstract ，抽象方法，只有方法名字，没有方法 的实现
    public abstract void doSomething();


    //1.不能new这个抽象类，只能靠子类去实现它：约束！
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象  ：约束~

    //思考题？  new    ，存在构造器吗？
    //    存在 的意义    抽象出来   提高开发效率
}


package com.oop.demo07;
//抽象类的所有方法，继承了他的子类，都必须要实现它的方法，，，除非  这个类也是抽象的，那么则需要他的子字类去实现他的方法
public  class A extends Action{
    @Override
    public void doSomething() {

    }
}

7.5.2、接口

  • 普通类：只有具体实现
  • 抽象类：具体实现和规范（抽象方法）都有
  • 接口：只有规范！自己无法写方法~ 专业的约束！约束和实现分离：面向接口编程~
  • 声明类的关键字是class，声明接口的关键字是interface
package com.oop.demo08;

// 抽象的思维~java 架构师
// interface 定义的关键字，接口都需要有实现类
public interface UserService {

    //常量~ public static final
    int AGE = 99;


    //接口中所有的定义的方法其实都是抽象的  public abstract   这两个关键字省略了

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);


}

package com.oop.demo08;

public interface TimeService {
    void timer();
}


package com.oop.demo08;
//抽象类   ： extends
//类  可以实现接口   implements 接口
//实现了接口的类，就需要重写接口中的方法~
//多继承~利用接口实现多继承~
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}
  • 作用：
    1. 约束
    2. 定义一些方法，让不同的人实现 10----->1 10个人去实现一个接口
    3. public abstract
    4. public static final
    5. 接口不能被实例化~，接口中没有构造方法
    6. implements可以实现多个接口
    7. 必须要重写接口中的方法

7.6、内部类及OOP实战

7.6.1、内部类

  • 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相当于A类来说就称为内部类，而A类相对B类来说就是外部类了。
    1. 成员内部类
    2. 静态内部类
    3. 局部内部类
    4. 匿名内部类

8、异常

8.1、什么是异常

Exception

8.2、异常体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bkg0Nxws-1647436554843)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220316201552307.png)]

8.3、java异常处理机制

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

        //假设要捕获多个异常 ：从小到大！

        try {//try监控区域
            System.out.println(a/b);
        } catch (Exception e) {//catch（想要捕获的异常类型！）捕获异常
            System.out.println("Exception");
        } catch (Throwable t){
            System.out.println("Throwable");
        } finally {//处理善后工作
            System.out.println("finally");
        }
        //finally  可以不要finally，假设IO  资源  关闭！
    }
}


package com.exception.demo01;

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


        //ctrl + alt  +  t
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();//打印错误的栈信息
        } finally {
        }
    }
}

public class Test1 {
    public static void main(String[] args) {

        try {
            new Test1().test(1,0);
        } catch (ArithmeticException e) {
            //e.printStackTrace();
            System.out.println("错误");
        }
    }
    //假设这方法中，处理不了这个异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
        System.out.println(a/b);
    }
}
输出：
    错误

8.4、处理异常

8.5、自定义异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l2mKRord-1647436554844)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220316210703685.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A6TMpO7c-1647436554844)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220316210722911.png)]

8.6、总结

alt + enter 处理报红，，后给出提示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kovg0INv-1647436554844)(C:/Users/陈权威/AppData/Roaming/Typora/typora-user-images/image-20220316211034665.png)]
int b = 0;

    //假设要捕获多个异常 ：从小到大！

    try {//try监控区域
        System.out.println(a/b);
    } catch (Exception e) {//catch（想要捕获的异常类型！）捕获异常
        System.out.println("Exception");
    } catch (Throwable t){
        System.out.println("Throwable");
    } finally {//处理善后工作
        System.out.println("finally");
    }
    //finally  可以不要finally，假设IO  资源  关闭！
}

}

package com.exception.demo01;

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

    //ctrl + alt  +  t
    try {
        System.out.println(a/b);
    } catch (Exception e) {
        e.printStackTrace();//打印错误的栈信息
    } finally {
    }
}

}

public class Test1 {
public static void main(String[] args) {

    try {
        new Test1().test(1,0);
    } catch (ArithmeticException e) {
        //e.printStackTrace();
        System.out.println("错误");
    }
}
//假设这方法中，处理不了这个异常，方法上抛出异常
public void test(int a,int b) throws ArithmeticException{
    if(b==0){
        throw new ArithmeticException();//主动抛出异常，一般在方法中使用
    }
    System.out.println(a/b);
}

}
输出：
错误






## 8.4、处理异常





## 8.5、自定义异常

[外链图片转存中...(img-l2mKRord-1647436554844)]

[外链图片转存中...(img-A6TMpO7c-1647436554844)]

## 8.6、总结

alt  +  enter   处理报红，，后给出提示

[外链图片转存中...(img-kovg0INv-1647436554844)]
_Promiseº
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第一阶段：狂神说——javaSE(基础)
qq_44697268的博客
07-10 591
狂神说java，学习笔记，javaSE第一阶段，打基础基础，
【狂神说】JavaSE系列.zip
10-16
【狂神说】JavaSE系列.zip 是一个包含Java标准版（Java Standard Edition，简称JavaSE）相关学习资源的压缩包，出自知名IT教育者“狂神”的网站。这个压缩包很可能是狂神为了帮助初学者和进阶者深入理解Java编程语言...
Java学习(二)---SE阶段回顾
最新发布
weixin_47109902的博客
10-09 221
JavaSE回顾(二)
狂神说笔记-javaSE基础
m0_62494533的博客
08-05 188
狂神说java基础笔记
JavaSE回顾总结（狂神说java）.xmind
05-11
javaSE回顾总结，学习笔记，查漏补缺。 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等.
狂神说学习JavaSE
我是一只蘑菇17的博客
09-24 256
2
JavaSE回顾总结（狂神说Java）
Monster1999的博客
09-15 471
JavaSE回顾总结（狂神说Java）
狂神javase基础（多态）
m0_64732310的博客
03-30 277
狂神javase基础（多态） 多态：我认为是（我们人被父亲继承下来后可以当各式各样的职业） 条件： ​ 继承 的关系； 父类方法的重写；父类引用指向子类的对象 ​ 子类重写父类的方法，执行子类的方法时（编译看左边，运行看右边） ​ 父类类型 变量名 = new 子类类型（） 准备工作： 继承特点： ​ 一个子类对应一个父类，没有父类时编译默认继承Object类（父类也一样），不能继承父类的构造方法 可以用super在子类的构造方法的首句 中调用父类*(无参构造除外）* 重写特点： ​ 子类根据需求从继
狂神说笔记内容.zip
08-15
【狂神说Java入门笔记】是一份针对初学者的详细教程资源，主要涵盖了Java语言的基础知识，旨在帮助学习者从零开始掌握Java编程。压缩包内的"JavaSE：Java入门.pdf"是主体教程文档，而"说明.txt"则包含了一些关于文件...
狂神说java系列笔记（java基础+javaweb+ssm+微服务）全套
04-26
【标题】：“狂神说java系列笔记”涵盖了Java的基础、Web开发、SSM框架以及微服务等关键领域，是一套全面深入的Java学习资源。它旨在帮助初学者和进阶者掌握Java编程语言的核心概念，以及在实际项目开发中的应用。 ...
JDk1.8中文帮助文档.zip / 免费下载
10-15
jdk1.8的中文帮助文档，免费下载
狂神说Java笔记资料
04-14
《狂神说Java笔记资料》是一份全面涵盖Java开发基础知识的文档集，旨在帮助学习者系统地掌握Java编程。这份笔记包含多个章节，每个章节都深入讲解了一个特定的主题，覆盖了从初学者到进阶开发者必备的知识点。 1. *...
狂神说java系列笔记（java基础+javaweb+ssm+微服务）.rar
01-08
【狂神说java系列笔记】是一份全面涵盖Java学习路径的综合资料，从基础到进阶，再到现代企业级开发的必备技术。这份资源旨在帮助Java开发者深入理解语言特性和应用实践，提升技能水平。 首先，从【Java基础】部分...
狂神说--javase04--方法详解
Mar.三月
04-19 225
这篇博客，我们也学点基础的，方法。 方法 方法是啥 方法的定义及调用 方法的重载 命令行传递参数 可变参数 递归 方法是啥 方法：实现某个功能的语句块的集合 方法是解决一类问题的步骤的有序集合 方法在程序中被创建，在其他地方被引用 命名规则：驼峰 方法的定义及调用 ...
狂神说 JavaSE入门笔记
weixin_45380637的博客
12-02 1209
狂神说 JavaSE入门笔记 4 基础 4.1 注释 comments 书写注释是非常好的习惯 Java中有三种注释 单行注释 多行注释 文档注释 文档注释 /** @Author lee */ 4.2 标识符 类名，变量名，方法名都被称为标识符 标识符以字母，美元符，下划线开始 不能使用关键字作为方法名或者变量名… 大小写敏感 可以使用中文作为变量名，但不建议 4.3 关键字 事先定义的，有特别意义的标识符，有时又叫保留字 String 不是关键字，String是一个类 4.4 数据类型 强类型语言
【狂神说Java】阶段一笔记34. javaSE总结
Yy_sushine的博客
02-10 276
PS：学习自狂神说java
狂神JAVASE系列-流程控制篇
jklove9的博客
05-04 1426
1. 用户交互Scanner 1.1 Scanner对象： Java提供的一个工具类，利用Scanner类可以获取用户的输入。 java.util.Scanner是java5新特性 1.2 基本语法 Scanner scanner = new Scanner(System.in); 类 对象名（随便） 1.3 注意 通过Scanner类的next()和nextLine()方法获取输入的字符串，在读取前通常会使用hashNext()与hashN...
【狂神说笔记—— javaSE总结图】
weixin_46055348的博客
07-11 214
【狂神说笔记—— javaSE总结图】
狂神说 mybatis 课程笔记
05-18
在学习之前，需要具备JDBC、MySQL和Java基础知识以及对Maven和Junit的了解。 MyBatis是一款优秀的持久层框架，它避免了编写大量的JDBC代码以及手动设置参数和获取结果集的繁琐过程。MyBatis可以使用简单的XML或注解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值