YS-JAVA

杨阿阳

已于 2022-03-22 12:36:37 修改

阅读量389

点赞数 1

文章标签： java

于 2021-03-12 17:49:01 首次发布

本文链接：https://blog.csdn.net/qq_45899812/article/details/114701974

版权

# 一、Markdon学习(查看源代码)

1.1 标题

//# + 标题内容

1.2 字体

1.粗体：

hello world

2.斜体

hello world

3.又斜又粗体

hello world

4.废弃字体

~~hello world~~

1.3 引用

hello world

1.4 分割线

1.5 图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bIPF2Rzb-1615542416199)(C:\Users\YS\Pictures\Saved Pictures\屏幕截图 2020-11-12 163536.png)]

1.6 超链接

[点击跳转到B站主页](杨阿阳Y的个人空间 - 哔哩哔哩 ( ゜- ゜)つロ乾杯~ Bilibili)

1.7 列表

1.8 表格

右键插入
名字性别生日
ys 男 2001.3.16

名字	性别	生日
ys	男	2001.3.16

1.9 代码

二、DOS命令

2.1 打开CMD方式

开始菜单寻找
WIN + R 后输入cmd
任意位置按住shift + 右键打开Powershell
在文件地址栏前面输入cmd+空格

2.2 基本命令

#盘符切换
D:

#查看当前选中盘所有文件
dir

#切换目录
cd /d D:

# 进入
cd+文件名

#返回上一级
cd.. 

#清理屏幕
cls 

#退出终端
exit 

#查看电脑ip
ipconfig 

#打开应用
calc
mspaint
notepad

#ping 命令
ping www.baidu.com

#文件操作 4
 md 目录名
 rd 目录名
 cd> 文件名
 del 文件名

三、安装/卸载JDK

3.1安装

百度jdk8，下载
安装
配置环境变量
- 新建系统变量 JAVA_HOME (jdk位置为变量值)
- PATH中新建%JAVA_HOME%&\bin与%JAVA_HOME%\jre\bin
测试jdk安装，打开cmd输入 java -version

3.2卸载

删除JVAV安装目录
删除JAVA_HOME
删除PATH下关于JAVA的目录
java -version

四、万恶之源Hello world

4.1步骤

新建文件夹，储存代码
新建一个java文件
- 文件后缀名为java
- Hello.java

编写代码

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

cmd中编译java文件(javac Hello.java),生成一个class文件
cmd中运行class文件(java Hello)

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

4.2 误区

五、idea的安装与使用

六、JAVA基础语法

6.1 注释

1.种类

单行注释
多行注释
文档注释

2.语法

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

3.例子

/***
 *                        d*##$.
 *  zP"""""$e.           $"    $o
 * 4$       '$          $"      $
 * '$        '$        J$       $F
 *  'b        $k       $>       $
 *   $k        $r     J$       d$
 *   '$         $     $"       $~
 *    '$        "$   '$E       $
 *     $         $L   $"      $F ...
 *      $.       4B   $      $$$*"""*b
 *      '$        $.  $$     $$      $F
 *       "$       R$  $F     $"      $
 *        $k      ?$ u*     dF      .$
 *        ^$.      $$"     z$      u$$$$e
 *         #$b             $E.dW@e$"    ?$
 *          #$           .o$$# d$$$$c    ?F
 *           $      .d$$#" . zo$>   #$r .uF
 *           $L .u$*"      $&$$$k   .$$d$$F
 *            $$"            ""^"$$$P"$P9$
 *           JP              .o$$$$u:$P $$
 *           $          ..ue$"      ""  $"
 *          d$          $F              $
 *          $$     ....udE             4B
 *           #$    """"` $r            @$
 *            ^$L        '$            $F
 *              RN        4N           $
 *               *$b                  d$
 *                $$k                 $F
 *                 $$b                $F
 *                  $""               $F
 *                  '$                $
 *                   $L               $
 *                   '$               $
 *                    $               $
 */

6.2 标识符

1.常用标识符

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

2.注意

不能使用关键字作为变量名、方法名、类名字…
所有标识符都应该以字母(A-Z,a-z)，美元符($)，下划线(_)开头

例如：String Ahello = “YS”;

~~String 1hello = “YS”~~;
$\textcolor{red}{标识符大小写敏感} $

例如：String Ahello = “YS”;

String ahello = “YS”;

6.3 数据类型

JAVA是强类型语言，要求变量的使用要严格符合规定，所有变量都必须先定义后使用

1.分类

①基本数据类型

数值类型：
- 整数类型
  - byte：占1个字节范围-128~17
  - short：占2个字节范围-32768~32767
  - int：占4个字节范围-2147483648~2147483647
  - long：占8个字节范围-9223372036854775808~9223372036854775807
- 浮点类型
  - float：占4个字节
  - double：占8个字节
- 字符类型
  - char：占2个字节
- 布尔类型：
  - true
  - false
引用数据类型
- 类
- 接口
- 数组

注： 1.String 不是数据类型，而是一个类

2.1byte （字节）= 8bit（位）—> 1B = 8b

②拓展

整数：
- 进制
  - 二进制：0b
  - 八进制：0
  - 十进制：10
  - 十六进制：0x （0~9 —> A~F）

public class 数据类型 {
    public static void main(String[] args) {
        int a1 = 0b1;
        int a2 = 010;
        int a3 = 10;
        int a4 = 0x10;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);
    }
}

浮点数：由于浮点数有限，离散，舍入，大约，接近但不等于，所以比较时候会有误差，用于比较是使用BigDecimal数学工具类

public class 数据类型 {
    public static void main(String[] args) {	    
        float f1 = 0.1f;
        double b2 = 1.0/10;
        System.out.println(f1 == b2);
        float f2 = 2121212121221f;
        float f3 = f2 + 1;
        System.out.println(f2 == f3);
    }
}

字符：所有的字符本质还是数字（由于Unicode编码表，用UXXXX表示）

public class 数据类型 {
    public static void main(String[] args) {  
        char c1 = 'a';
        char c2 = '杨';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
    }
}

转义字符
- \t
- \n
布尔值

if(A == true)
if(A)
//上述两代码等价，多用第二行

2.类型转换

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

byte.short,char->int->long->float(小数优先级大于整数)->double

①强制转换（高->低）

(类型)变量名

public class 类型转换 {
    public static void main(String[] args) {
        double d1 = 3.14;
        int i1 = (int)d1;
        System.out.println(d1);
        System.out.println(i1);
    }
}

②自动转换（低->高）

public class 类型转换 {
    public static void main(String[] args) {
        int i2 = 5;
        double d2 = i2;
        System.out.println(i2);
        System.out.println(d2);
    }
}

③注意

不能对布尔值进行转换
不能把对象类型转换为不相干类型
转换时候可能存在内存溢出，精度问题

public class 类型转换 {
    public static void main(String[] args) {
        int money = 10_0000_0000;
        int year = 20;
        int total = money * year;
        long total1 = money * year;   //转换之前就存在内存溢出问题
        long total2 = money * (long)year;
        System.out.println(total);
        System.out.println(total1);    
        System.out.println(total2);
    }
}

6.4 变量与常量

变量：可以变换的量，是java程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

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

1.语法

//变量
type varName = value;
//常量
final 常量名 = 值;

2.注意

每个变量都有类型，可以是基本类型，也可以是引用类型
变量名必须是合法的标识符
变量的每一个声明都必须以分号结束

3.作用域

public class 变量 {
    //实例变量：从属于对象，如果不自行初始化，这个类型的默认值为0/0.0
    //布尔值默认值为false
    //除了基本类型，其他默认值都是null
    String name;
    int age;
    //类变量
    static double money = 4000;
    //常量
    static final double pi = 3.14;
    public static void main(String[] args) {
        //局部变量
        int a = 1;
        int b = 2;
        int c = 3;
        String name = "yangshuo";
        char x = 'Y';
        double pi = 3.14;
        //实例变量
        变量 A = new 变量();
        A.name = "杨硕";
        System.out.println(A.name);
        System.out.println(A.age);
        //类变量
        System.out.println(money);
        //常量
        System.out.println(pi);
    }
    public void another(){
    }
}

4.命名规范

类成员变量：首字母小写的驼峰原则 lastName
局部变量：首字母小写的驼峰原则 lastName
常量：大写字母和下划线 LAST_NAME
类名：首字母大写的驼峰原则 LastName
方法名：首字母小写的驼峰原则 lastName()

6.5 运算符

1.类别

算数运算符:+,-,*,/,%,++,–
赋值运算符: =
关系运算符: >,<,>=,<=,==,!=,instanceof
逻辑运算符:&&,||,!
位运算符:&,|,^,~,>>,<<,>>>
条件运算符; ? :
扩展赋值运算符: += ,-=, *=, /=

2.例子

①算数运算符

package basic;

public class 运算符 {
    public static void main(String[] args) {
        //二元运算符
        int a = 11;
        int b = 12;
        int c = 13;
        int d = 14;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a /(double) b);
        System.out.println("---------------------------------------------");
        int i1 = 2;
        byte b1 = 4;
        short s1 = 8;
        long l1 = 11111231313321l;
        System.out.println(i1+b1+s1+l1); //long
        System.out.println(i1+b1+s1); //int
        System.out.println(s1+l1); //int
        System.out.println("---------------------------------------------");
        System.out.println(a > b);
        System.out.println(a < b);
        System.out.println(a == b);
        System.out.println(a != b);
        System.out.println(b % a);
    }
}

②一元运算符

package basic;

public class 一元运算符 {
    public static void main(String[] args) {
        int a = 2;
        int b = a++;
        //执行上行之后执行了a = a + 1;
        System.out.println(a);
        System.out.println("------------------------------");
        //执行下行之前执行了a = a + 1;
        int c = ++a;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

③逻辑运算符

package basic.运算符;

public class 逻辑运算符 {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        //逻辑与
        System.out.println("a && b :" + (a && b));
        //逻辑或
        System.out.println("a || b :" + (a || b));
        //逻辑非
        System.out.println("!(a && b) :" + !(a && b));
        System.out.println("----------------------------------");
        //证明：当逻辑与第一个为假时不执行第二个
        int c = 1;
        boolean d = (b && c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}

④位运算

A = 0011 1100 , B = 0000 1101

A&B	A\|B	A^B	~B
0000 1100	0011 1101	0011 0001	1111 0010

左移<< ：*2

右移>>：/2

3.赋值运算符拓展

public class 拓展赋值运算符 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        a+=b; //a = a + b;
        a-=b; //a = a - b;
        System.out.println(a);
        System.out.println("----------------------");
        System.out.println("" + a+b);//输出是出现String则会把所有都变成String类型
        System.out.println(a+b + "");//字符串在后面则不会
    }
}

4.三元运算符

x?y:z

如果x == true ，则结果为y，否则为z；

6.6 包机制

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间

语法：

package pkg1[.  pkg2[.  pkg3....]];   //创建
import package1[.package2...](classname/*);

一般利用公司域名倒置作为包名，例如百度：com.baidu.www

6.7 JavaDoc

JavaDoc命令是用来生成后悔自己API文档的

参数信息

@author 作者号
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

@author	作者号
@version	版本号
@since	指明需要最早使用的jdk版本
@param	参数名
@return	返回值情况
@throws	异常抛出情况

1.用cmd生成doc文件

javadoc -encoding UTF-8 -charest UTF-8 classname.java

2.用idea生成doc文件

第一步：在工具栏中找到 Tools，然后再子菜单中找到 Generate JavaDoc
第二步：在生成文档上进行配置

配置的简单介绍

1.Whole project:整个项目都生成文档

2.Custom scope 自定义范围。如下：

（1）project files 项目文件，

（2）project production files 项目产品文件，

（3）project test files 项目的测试文件，未知范围，class hierarchy 类层

3.include test source 包含测试目录

4.include JDK and … 包含jdk和其他的第三方jar

5.link to JDK documentation…链接到JDK api

6.output directy 生成的文档存放的位置

（1）private、package、protected、public 生成文档的级别（类和方法）

（2）右边的Generate…是选择生成的文档包含的内容，层级树、导航、索引…

（3）再右边是生成的文档包含的内容信息，作者版本等信息

7.Locale 语言类型,zh-CN

8.Other command line arguments 其他参数

9.Maximum heep… 最大堆栈

说明：

IntelliJ IDEA作为Java流行的编辑器, 其生成一些Javadoc会对中文乱码, 使用UTF-8编码即可.

这个常见的问题, 则需要生成时设置参数即可

在 “Tools->Gerenate JavaDoc” 面版的 “Other command line arguments:” 栏里输入：
-encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/7/docs/api

转载自：

作者：逝者如斯灬
链接：https://www.jianshu.com/p/0ddb0864e499
来源：简书

七、java流程控制

7.1 用户交互scanner

1.两个方法

①next()

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

public class Scanner1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);  //创建一个扫描器对象，用于接受键盘数据
        System.out.println("使用next方式接收");
        if(scanner.hasNext()){                    //判断用户是否输入字符串
            String str = scanner.next();          //使用next方式接收
            System.out.println("输出的内容为：" + str);
        }
        scanner.close();     //凡事io流的类如果不关闭会一直占用资源，养成习惯用完就关闭
    }
}

②nextLine()

以Enter为结束符
可以获得空白

public class Scanner2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方法接收");
        if(scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

2.补充用法

has next 有不同的数据类型

public class scanner3 {
    public static void main(String[] args) {
        Scanner  scanner = new Scanner(System.in);
        System.out.println("请输入整数数据");
        if(scanner.hasNextInt()){
            int i = scanner.nextInt();
            System.out.println("整数为："+i);
        }else{
            System.out.println("输入的不是整数数据");
        }
        scanner.close();
    }
}

3.实例

计算平均数，在每次输出时显示详细信息

public class Scanner4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i = 0;
        double d1,d2 = 0;
        System.out.println("平均数计算器！如果要结束请输入除数字意外任意字符！");
        System.out.println("请输入数据：");
        while(s	canner.hasNextDouble()){
            d1 = scanner.nextDouble();
            i++;
            System.out.println("您输入的第" +i+ "个数据为：" + d1);
            d2 = d1 + d2 ;
        }
        System.out.println("平均数为：" + d2/i);
        scanner.close();
    }
}

7.2 顺序结构

package com.YSJAVA.流程化控制;

public class 顺序结构 {
    public static void main(String[] args) {
        System.out.println("Hello 1");
        System.out.println("Hello 2");
        System.out.println("Hello 3");
        System.out.println("Hello 4");
        System.out.println("Hello 5");
    }
}

7.3 选择结构

1.if选择结构

①单选择

import java.util.Scanner;

public class 单选择 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        if(scanner.hasNextInt()){
            System.out.println("您的成绩为：" + scanner.nextInt());
        }
        else{
            System.out.println("成绩输入错误！");
        }
        scanner.close();
    }
}

②双选择

import java.util.Scanner;

public class 双选择 {
    public static void main(String[] args) {
        System.out.println("请输入您的成绩！");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        if(i > 60){
            System.out.println("成绩及格！");
        }
        else{
            System.out.println("成绩不及格！");
        }
        scanner.close();
    }
}

③多选择

import java.util.Scanner;
public class 多选择 {
    public static void main(String[] args) {
        System.out.println("请输入您的成绩！");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        if (i > 0 && i < 60) {
            System.out.println("成绩不及格！");
        } else if(i >= 60 && i < 90){
            System.out.println("成绩及格！");
        }else if(i >= 90 && i <= 100){
            System.out.println("成绩优秀！");
        }else{
            System.out.println("输入成绩成绩无效！");
        }
        scanner.close();
    }
}

2.switch选择结构

switch case语句判断一个变量与一系列值中某个值是否相等，每个值成为一个分支
switch语句中的变量类型可以是
- byte，short，int或者char
- JAVE SE7 开始支持String类型
- case标签必须为字符串常量或者字面量

public class Switch {
    public static void main(String[] args) {
         char grade = 'C';
         switch(grade){
             //case具有穿透现象，如果case后没有break，程序会一直向下进行
             //jdk7 新特性: switch支持String，例如String name = "ZS"; Switch(name);
             //反编译 java————class————反编译（IDEA:将class文件放入IDEA）
             case 'A':
                 System.out.println("优秀");
             case 'B':
                 System.out.println("良好");
             case 'C':
                 System.out.println("及格");
             case 'D':
                 System.out.println("挂科");
                 break;
             default:
                 System.out.println("未知等级");
         }
    }
}

7.4 循环结构

1.while循环

语法:

while(布尔表达式){
   //代码语句
}

while是最基本的循环
只要表达式为true，就会一直进行下去

public class While {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        while(i <= 100){
            sum = sum + i;
            i++;

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

2.do while 循环

语法:

do{
    //代码语句
}while(布尔表达式);

循环至少执行一次
do while 是执行后判断

public class DoWhile {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do{
            sum = sum + i;
            i++;
        }while(i <= 100);
        System.out.println(sum);
        System.out.println("-------------------以下代码展示while与do while区别-----------------------");
        do{
            System.out.println("执行了do while循环");
        }while(i < 0);
        while(i < 0){
            System.out.println("执行了while循环");
        }
    }
}

3.for循环

语法：

for(初始化;布尔表达式;更新){
    //代码语句
}

说明：

最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
然后检测布尔表达式的值，true执行循环体，false循环终止
for( ; 😉{} 成立，死循环

例子

public class For1 { //分别计算1-100奇数偶数的合
    public static void main(String[] args) {
        int sumA = 0;
        int sumB = 0;
        for (int i = 0; i <= 100; i++) {
            if(i%2 == 0){
                sumA = sumA + i;
            }
            else{
                sumB = sumB + i;
            }
        }
        System.out.println("偶数合为：" + sumA);
        System.out.println("奇数合为：" + sumB);
    }
}
--------------------------------------------------------------------------------------------------------
public class For2 { //输出1-1000能被5整除的数，并且每行输出三个
    public static void main(String[] args) {
        for (int i = 1; i < 1000; i++) {
            if(i%5 == 0){
                System.out.print(i + "\t");
            }
            if(i%15 == 0){
                System.out.println("\n");
            }
        }
    }
}
--------------------------------------------------------------------------------------------------------
public class For3 { //打印99乘法表
    public static void main(String[] args) {

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

增强for循环：

public class For4 {
    public static void main(String[] args) {
        int numbers[] = {1,2,4,5,6,7};
        for (int i = 0; i < 6; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("-----------------------------");
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

7.5 break & continue

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句

public class BreakCotinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            if(i==5){
                break;     //break只是跳出循环，并不是结束程序
            }
        }
        System.out.println("hello");
    }
}

continue语句在循环语句中，用于终止某次循环过程，跳过尚未执行的语句，进行下一次是否执行的判定

public class BreakCotinue {
    public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
            if(i%10 == 0){
                System.out.println(" ");
                continue;
            }
            System.out.println(i);
        }
    }
}

7.6 练习

八、方法

8.1 方法定义

方法是一段用来完成特定功能的代码片段

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

/*
修饰符 返回值类型 方法名(参数类型 参数名字){
    ...
    方法体
    ...
    return 返回值;  //return 0 可以结束方法
}
*/

8.2 方法重载

规则
- 方法名称必须相同
- 参数列表必须不同（个数，类型，参数排列顺序）
- 方法的返回类型可以相同也可以不同
- 仅仅返回类型不同不足应成为方法重载

public class 方法重载 {
    public static void main(String[] args) {
       int a = 1,b = 2;
       double c = 2.32,d = 2.33333;
        System.out.println(max(a,b));
        System.out.println(max(c,d));
    }

    public static double max(double num1,double num2){
        double result = 0;
        if(num1 == num2){
            System.out.println("大小相等！");
            return 0;
        }
        if(num1 < num2){
            result = num2;
        }else{
            result =num1;
        }
        return result;
    }
    public static int max(int num1,int num2){
        int result = 0;
        if(num1 == num2){
            System.out.println("大小相等！");
            return 0;
        }
        if(num1 < num2){
            result = num2;
        }else{
            result =num1;
        }
        return result;
    }
}

8.3 命令行传参

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

8.4 可变参数

JDK1.5开始，Java支持传递同类型的可变参数，一个方法中这只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在他之前声明

public class 可变参数 {
    public static void main(String[] args) {
        printMax(1,2,33,32235,5454,432,54);
    }
    public static void printMax(double...numbers){
        if(numbers.length == 0){
            System.out.println("没有数字传入");
        }
        double result = numbers[0];
        for (int i = 0; i < numbers.length; i++) {
            if(result < numbers[i]){
                result = numbers[i];
            }
        }
        System.out.println("最大值为：" + result);
    }
}

8.5 递归

递归就是A方法调用A方法自己，利用递归可以用简单的程序来解决一些复杂的问题

递归包括两个部分
- 递归头：什么时候不调用自身方法
- 递归体：什么时候需要调用自身方法

例子：5的阶层

public class 递归 {
    public static void main(String[] args) {
        System.out.println(fn(0));
    }
    public static int fn(int a){
        if(a == 1 || a == 0){
            return 1;
        }
        else{
            return (a * fn(a - 1));
        }
    }
}

九、数组

9.1 数组声明创建

数组是相同类型数据的有序集合，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们

1.数组的使用

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] nums; //1、声明一个数组

        nums = new int[10]; //2、创建一个数组

        nums[1] = 1;   //3、赋值
        nums[2] = 2;
        nums[3] = 3;
        nums[4] = 4;
        nums[5] = 5;
        nums[6] = 6;
        nums[7] = 7;
        nums[8] = 8;
        nums[9] = 9;
        System.out.println(nums[0]);
        System.out.println(nums[4]);
        int sum = 0 ;
        for (int i = 0; i <nums.length ; i++) {
            sum = nums[i] + sum;
        }
        System.out.println(sum);

    }
}

2.内存分析 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y1i20eeg-1615542416220)(C:\Users\YS\AppData\Roaming\Typora\typora-user-images\image-20210304113150766.png)]

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

3.初始化

静态初始化
动态初始化

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] a ={1,45,7,8,3,3}; //静态初始化
        System.out.println(a[2]);
        System.out.println("------------------------");
        int[] b = new int[10];   //动态初始化，包含默认初始化
        b[1] = 100;
        System.out.println(b[1]);
    }
}

4.特点

长度确定，一旦创建，大小不可改变
所有元素必须为相同类型
元素可以是任何数据类型，包括基本数据类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象实在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身实在堆中的

5.数组越界

~~java.lang.ArrayIndexOutOfBoundsException~~

出现上述错误提示则越界

9.2 数组使用

1 .for循环

2.For-Each循环

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays1 = {1,2,3,4,5,33};
        //打印全部数组元素
        for (int i = 0; i < arrays1.length; i++) {
            System.out.println(arrays1[i]);
        }
        System.out.println("----------------");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays1.length; i++) {
            sum+=arrays1[i];
        }
        System.out.println("sum:"+sum);
        System.out.println("----------------");
        //查找最大元素
        int max = arrays1[0];
        for (int i = 0; i < arrays1.length; i++) {
            if(max<arrays1[i]){
                max = arrays1[i];
            }
        }
        System.out.println("max:"+max);
        System.out.println("----------------");
        //-----------------------------------for each---------------------------------------------------
        //打印全部数组元素
        for (int i : arrays1) {
            System.out.println(arrays1);
        }
    }
}

3. 数组作方法入参

4.数组作返回值

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] a = {12, 4, 45, 67, 7};
        printArray(a);
        System.out.println("====上为正常，下为反转====");
        int[] temp = reverse(a);
        printArray(temp);
    }

    //打印数组类
    public static void printArray(int a[]) { //printArray方法的形参为数组
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

    //反转数组类
    public static int[] reverse(int a[]) { //此方法返回值为int形数组
        int[] result = new int[a.length];
        for (int i = 0, j = a.length - 1; i < a.length; i++, j--) {
            result[j] = a[i];
        }
        return result;
    }
}

9.3 多维数组

1、二维数组

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][] array = {{4,2},{3,2},{4,3}};
        System.out.println(array[0][1]);
        print(array);
    }
    public static void print(int[][]a){
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.println(a[i][j]);
            }
        }
    }
}

9.4 Arrays类

1.

官方提供的Arrays类，导入java.util.Arrays可使用

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,7655,3,2,465,5,2};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(a));
    }
}

2.冒泡排序

两层循环，外层冒泡轮数，里层依次比较

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {2,3,5,34,332,324,4,2,33,4};
        int b[] = sort(a);
        System.out.println(Arrays.toString(b));
    }


    public static int[] sort(int[] a){
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                int temp = 0;
                if(a[j+1] < a[j]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;
    }
}

时间复杂度 O(n2)

9.5 稀疏数组

package com.YSJAVA.数组;

public class ArrayDemo08 {
   public static void main(String[] args) {
       int[][] a = new int[10][11];
       a[1][3] = 2;
       a[3][4] = 3;
       //原始数组
       System.out.println("输出原始数组：");
       System.out.println(print(a));
       System.out.println("=======================");
       //转换数组
       int[][]b = trans(a);
       System.out.println("输出稀疏数组");
       System.out.println(print(b));
   }

   //转换为稀疏数组
    public static int[][] trans(int[][] array) {
       int sum = 0;
       for (int i = 0; i < array.length; i++) {
           for (int j = 0; j < array.length; j++) {
               if (array[i][j] != 0) {
                   sum++;
               }
           }
       }
       int[][] afarray =  new int[sum+1][3];
       afarray[0][0] = array.length;
       afarray[0][1] = array[0].length;
       afarray[0][2] = sum;
       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 ++;
                    afarray[count][0] = i;
                    afarray[count][1] = j;
                    afarray[count][2] = array[i][j];
                }
            }
        }
       return afarray;
   }
   //输出方法
   public static int[][] print(int[][] array){
       for (int[] ints : array) {
           for (int anInt : ints) {
               System.out.print(anInt + "\t");
           }
           System.out.println();
       }
       return array;
       }
   }

十、面向对象编程

10.1 方法回顾

面向对象编程（Object-Oriented Programming,OOP)

本质：以类的方式组织代码，以对象的组织封装数据

三大特性：封装，继承，多态

学会以下概念：

方法的定义
- 修饰符
- 返回类型
- break和return的区别
- 方法名
- 参数列表
- 异常抛出
方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字

10.2 对象的创建分析

1.对象的创建

//启动类，主类
public class Appliction {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.age = 10;
        student1.Name = "YS";
        System.out.println(student1.age);
        System.out.println(student1.Name);
    }
}
//学生类
public class Student {
    String Name =null;
    int age = 0;
}

2.构造器

//对象类
public class ConstructDdemo {
    //一个类如果什么都不写，系统会自动生成无参构造
    String name;
    int age;
    //alt + insert可以自动生成构造

    //构造器作用：
    //使用new关键字时，本质实在调用构造器
    //用来初始化值
    public ConstructDdemo() {}

    //有参构造，一旦定义了有参构造，无参构造就必须显示定义
    public ConstructDdemo(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

//启动类
public class ConstructAppDemo2 {
    public static void main(String[] args) {
        ConstructDdemo constructDdemo = new ConstructDdemo();
        constructDdemo.age = 16;
        constructDdemo.name = "YS";
        System.out.println(constructDdemo.age);
        System.out.println(constructDdemo.name);
    }
}

3.内存分析

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

快捷键：

alt+insert 自动生成代码

10.3 面向对象的三大特性

1.封装

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

封装

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问

总结：属性私有，get/set

public class Student {
    //属性私有
    private String name;
    private int id;
    private int age;

    //提供一些可以操作这个属性的方法
    //提供一些public的get set方法
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

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

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

2.继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

extends的意思的扩展，子类是父类的扩展

Java中类只有单继承，没有多继承

补充：

继承是类和类之间的一种关系，初次之外，类和类之间的关系还有依赖，组合，聚合等
继承关系的两个类，一个为子类(派生类)，一个为父类（基类）。子类 extends父类
子类和父类之间，从意义上讲具有“is a”关系，例如：老师是人，旺财是狗。

①object类

所有类都直接或者间接继承object

②super

public class Person {
    public Person() {
        System.out.println("Person的无参构造被调用");
    }
    protected String name = "YS";

    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person{
    public Student() {
        super(); //如果构造方法里采用super调用父类构造器必须放在第一行，如果不写，默认调用但是隐藏
        System.out.println("Student的无参构造被调用"); //执行子类时，先调用父类的无参构造，后调用子类的无参构造
        System.out.println("===================");
    }
    private String name = "YangShuo";
    public void test1(String name){
        System.out.println("name:"+name);
        System.out.println("this.name:"+this.name);
        System.out.println("super.name:"+super.name);
    }
    public void print(){
        System.out.println("Student");
    }
    public void test2(){
        print();
        this.print();
        super.print();
    }
}

public class App {
    public static void main(String[] args) {
        Student S1 = new Student();
        S1.test1("ys");
        System.out.println("===================");
        S1.test2();
    }
}

注意事项

super调用父类的构造方法时，必须是构造方法的第一个
super只能出现在子类的方法或构造方法中
super和this不能同时调用构造方法原因：Call to ‘super()’（或者’this()’）must be first statement in constructor body

super和this区别

代表对象不同

this：本身调用者这个对象
super：代表父类对象的应用

前提

this：没有继承也可以使用
super：有继承才能使用

构造方法

this：本类的构造
super：父类的构造

快捷键：

crtl+f 搜索

crtl+h 查看继承结构图

③方法的重写

需要有继承关系，子类重写父类的方法

要求：

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大（范围：Public > Protected > Default > Private）
抛出的异常：范围可以被缩小

public class A {
    public void test(){
        System.out.println("YS:我身高一米八");
    }
}



public class B extends A{
    @Override
    public void test() {
        super.test();
        System.out.println("STY:我身高才一米七！！！！");
    }
}



public class App {
    public static void main(String[] args) {
        A YS = new A();
        YS.test();
        System.out.println("=======");
        B STY = new B();
        STY.test();
        System.out.println("=======");

        System.out.println("=======");
        A YS1 = new B();
        YS1.test();
    }
}

作用：父类的功能子类不一定需要/满足

3.多态

① 例子

public class Animal {
    public void shout(){
        System.out.println("动物在叫");
    }
}


public class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪汪");
    }
}


public class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵");
    }
}

public class App {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Cat cat = new Cat();
        Dog dog = new Dog();
        System.out.println("animal.shout():");
        animal.shout();
        System.out.println("cat.shout():");
        cat.shout();
        System.out.println("dog.shout():");
        dog.shout();

        //父类的引用指向子类
        Animal animal1 =new Cat();
        System.out.println("animal1.shout():");
        animal1.shout();
    }
}

②注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系，类型转换异常！ClassCastException
存在条件：继承关系，方法重写，父类的引用指向子类

③instanceof、类型转换

        //强制转换   高位——————>低位
        Animal A1 = new Animal();
        Dog D1 = new Dog();
        Animal A2 = (Animal)D1;
        A2.shout();

        //instanceof 判断一个对象是什么类型,输出结构位true or false
        System.out.println(A2 instanceof Animal);

④static

public class Demo01 {
    //带有static关键字的静态属性被所有类共享
    private static int age;
    private double score;

    public static void run(){}
    public void go(){
        run();  //非静态方法可以调用静态方法
    }


    public static void main(String[] args) {
        Demo01 d1 = new Demo01();
        System.out.println(d1.age);
        System.out.println(Demo01.age);   //属性不仅可以通过对象访问还可以通过类来访问
        run();
        //go();  //静态方法只能调用静态方法
    }
}

public class Demo02 {
    {
        System.out.println("匿名代码块");      //第二个被执行
    }

    static{
        System.out.println("静态代码块");      //第一个被执行,且只执行一次
    }

    public Demo02(){
        System.out.println("构造方法");         //第三个被执行
    }

    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();
        System.out.println("=================");
        Demo02 demo002 = new Demo02();
    }
}

注意：如果在类前加final此类不能被继承

10.4 抽象类和接口类

1.抽象类（不常用）

具有实现和规范（抽象方法）

//抽象类
//1.不能new抽象类，只能靠子类去实现它
//2.抽象类中可以写普通的方法
//3.抽象方法必须在抽象类中
public abstract class A {
    //抽象方法，只有名字没有实现
    public abstract void dosomething();
    
}

2.接口类（常用）

只有规范，无法写方法

//定义关键字：interface
public interface Demo01 {
    //接口中的所有定义默认都为public static final,但一般不使用
    int age = 99;
    //接口中的所有定义默认都为public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

public interface Demo02 {
    void time();
}

//类 可以实现接口 关键字implements 当定义了接口的实现类，必须重写接口中的所有方法
//实现类可以实现多个接口
public class Demo01Impl implements Demo01,Demo02{  
    @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 time() {

    }
}

②注意

约束，定义一些方法，让不同的人实现
接口不能被实例化

10.5 内部类和OOP实战

1.内部类

public class Demo01 {
    private int id = 111;
    public  void  out(){
        System.out.println("这是外部类的方法");
    }
    public  class inner{
        public void innerway(){
            System.out.println("这是内部类的方法");
        }
        public void getid(){
            //内部类可以获得外部类的私有属性
            System.out.println(id);
        }
    }

}

public class App {
    public static void main(String[] args) {
        //可以通过外部类来实例内部类
      Demo01 d1 = new Demo01();
        Demo01.inner in = d1.new inner();
        in.innerway();
        in.getid();
    }
}

十一、异常机制

10.1什么是异常

运行中出现的不期而至的各种状态，如：文件找不到，网络连接失败，非法参数等

异常发生在程序运行期间，它影响了正常的程序执行

1.分类

检查性异常：用户错误或问题引起的异常，这是程序员无法遇见的，例如要打开一个不存在的文件时，发生异常
运行时异常：可能被避免的异常，运行时异常可以在编译时被忽略
（错误：错误不是异常，而是脱离程序员控制的问题，错误在代码中通常被忽略，例如当栈溢出时，发生错误，在编译当中检查不到）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GCmHELnK-1615542416223)(C:\Users\YS\AppData\Roaming\Typora\typora-user-images\image-20210312123440001.png)]

10.2 异常处理机制

抛出异常，捕获异常；五个关键字：try catch finally throw throws

public class 语法 {
    public static void main(String[] args) {
        int a = 0;
        int b = 1;
        try{  //监控区域，在try内的异常可以被捕获
            System.out.println(b/a);
        }catch(Error e){  //捕获异常 catch(异常类型)应该从小范围到大范围依次进行捕获
            System.out.println("Error");
        }catch(Exception e){
            System.out.println("Exception"); 
        }catch(Throwable e){
            System.out.println("Throwable");
        }finally {   //处理善后工作，可以没有，但是try，catch必须有，finaly可以用来做资源的关闭
            System.out.println("finally");
        }
    }
}

public class Demo01 {
    public static void main(String[] args) {
        try {
            new Demo01().test(0,2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

}

快捷键：Crtl+alt+t 包裹代码

杨阿阳

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
YS-JAVA

# 一、Markdon学习(查看源代码)1.1 标题//# + 标题内容1.2 字体1.粗体：hello world2.斜体hello world3.又斜又粗体hello world4.废弃字体hello world1.3 引用hello world1.4 分割线1.5 图片[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bIPF2Rzb-1615542416199)(C:\Users\YS\Pictures\Saved Picture
复制链接

扫一扫