JAVA环境安装

下载JDK8

如果你电脑上java版本很多，那就先翻到末尾看看Java版本管理，Java版本更新一次换一次，导致Java要安装很多版本，但是环境变量好像只能配置一个Java版本，GG
参考博客：https://zhuanlan.zhihu.com/p/698660989
主流的应该还是JDK8
前往官网下载：https://www.oracle.com/java/technologies/downloads/archive/
点击Java archive

然后往下滑，找到该位置

然后下滑找到并点击

这里要求登录账户，注册一个账号登录即可
然后点击安装程序安装，然后选择安装jdk的目录

下载好之后更改java安装的路径

配置JDK

找到JDK的安装路径，找到bin、conf文件夹，然后复制路径

然后打开环境变量，选中此电脑，然后右键选择属性

选中环境变量

系统环境变量中选择新建

然后在系统环境变量path中添加javapath
复制目录位置

再win + R键，cmd进入终端，出现如下图所示，这样就环境变量就配置好了

Hello World

直接写一个java代码

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

然后直接在保存java代码的文件目录下cmd进入终端

然后输入指令javac hello.java，如果没有报错那么编译完就会出现hello.class文件

由于我的电脑事先有安装更高版本的java，所以在使用java运行的时候会出现错误，所以我需要使用javac --release 8 Hello.java这个指令进行编译
在终端中再使用指令java hello，执行编译后的文件

注意：

每个单词的大小不能出现问题，Java是大小写敏感的
尽量使用英文
文件名和类名必须保证一致
符号使用中文会报错

IDEA安装

在浏览器搜索IDEA，这个就是IDEA的官网

在点击开发者工具，选择IntelliJ IDEA，然后点击下载

然后打开安装程序，选择安装目录，之后勾选这两个

然后新建一个项目

新建项目配置如下

然后写Hello World程序
先创建一个Hello.java文件

写好后点击绿色箭头即可运行

得到想要的结果

创建一个空项目

然后选择项目创建的文件夹

新建程序文件就new，然后点击Module选项，然后再为模块取个名字即可

然后编辑一下项目结构

按照如下编辑

然后创建java文件，选中src,并点击鼠标右键

然后测试一下Hello,World!，能运行成功

Java基础

Java注释

注释并不会被执行，而是写给人看的，在编译的时候，编译器会自动忽略注释
Java注释有三种：
- 单行注释：在一行中使用//表示单行注释
- 多行注释：在多行中使用/**/表示多行注释
- 文档注释：文档注释中使用/** */表示文档注释，并且每一行注释的开头都需要加上*，文档注释除了给人看之外，还有一些功能

public class HelloWorld {
    public static void main(String[] args) {
        //输出一个Hello，World！----这是一个单行注释

        /*
            输出一个Hello，World！
            ----这是一个多行注释
        */
        System.out.println("Hello,World!");
    }
    /**
     * ----这时一个文档注释，下面是Java文档注释的一些参数和功能
     * @Description HelloWorld
     * @Author aaaa
     */
}

Java标识符和关键字

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

标识符的一些注意点：
- 所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（_）开始
- 首字符之后可以是字母（A-Z或者a-z），美元符（$）、下划线（_）或数字的任何字符组合
- 不能使用关键字作为变量名或方法名
- 标识符区分大小写
- 可以使用中文命名，但是不建议

public class Demo01 {
    public static void main(String[] args) {
        String Ahello = "aaa";
        String hello = "aaa";
        String $hello = "aaa";
        String _hello = "aaaa";
        String Hello = "aaaa";
        String 王者荣耀 = "百星王者";
        System.out.println(王者荣耀);
    }
}

Java数据类型

Java是强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
变量：可以变化的量
- Java是一种强类型语言，每个变量都必须声明其类型。
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
- 注意：
  - 每个变量都有类型，类型可以是基本类型，也可以是引用类型
  - 变量名必须是合法的标识符
  - 变量名是一条完整的语句，因此每一个声明都必须以分号结束

type varName [=value] [{,varName[=value]}];
// 数据类型 变量名 = 值; 可以使用逗号隔开来声明多个同类型的变量。
public class Demo2 {
    public static void main(String[] args) {
        String a="hello",b = "beef",c = "cost";
        int num = 10;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(num);
    }
}

Java的数据类型分为两大类：基本类型、引用类型

public class Demo2 {
    public static void main(String[] args) {
    //八大基本数据类型

    //整数
    int num1 = 10; //最常用
    byte num2 = 20;
    short num3 = 30;
    long num4 = 30L;//Long类型要在数字后面加个L

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

    //字符
    char name = 'A'; //区分字符和字符串
    //字符串,String不是关键字，是一个类
    String namea = "AAA";

    //布尔值:
    boolean flag = true;
    //boolean flag = false;
}

拓展：整数类型、浮点数类型和字符类型的扩展

public class Demo3 {
    public static void main(String[] args) {
        int i = 10;
        int i2 = 010;//八进制0开头
        int i3 = 0x10;//十六进制0x开头

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

        //----------------------
        //float 有限的，离散的，具有舍入误差，有些只能接近大约，接近但不等于
        //BigDecimal数学工具类
        float f = 0.1f; //0.1
        double d = 1.0/10; //0.1
        System.out.println(f==d);//false
        System.out.println(f);//0.1
        System.out.println(d);//0.1

        float d1 = 323135153131351313f;
        float d2 = d1 + 1;
        System.out.println(d1==d2); // true

        //----------------------
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);// a
        System.out.println((int)c1);//97
        System.out.println(c2);//中
        System.out.println((int)c2);//20013
        //所有的字符本质还是数字，a--->97   A--->65
        //编码 unicode 2字节 65536
        char c3 = '\u0061';
        System.out.println(c3); //a
        //转移字符 \t 制表符
        System.out.println("Hello\tWorld");//Hello	World
        // \n 换行符
        System.out.println("Hello\nWorld");
        /*
        Hello
        World
        */
        //----------------------------------
        //对象 从内存分析
        String sa = new String("Hello world");
        String sb = new String("Hello world");
        System.out.println(sa==sb);//false

        String sc = "Hello world";
        String sd = "Hello world";
        System.out.println(sc==sd);//true

        //布尔值扩展
        //代码精简易读
        boolean flag =true;
        if(flag==true) {}
        if(flag){}
        }
    }
}

Java类型转换

在编程中都是会涉及到数据类型转换的
Java是强类型语言，所以要进行有些运算的时候，涉及到类型转换是必然的
- 在运算中，不同类型的数据先转换为同一类型，然后进行运算
- 数据类型的转换有：强制类型转换、自动类型转换

public class demo5 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;
        double c = i;// 内存溢出
        //强制转换，(类型)变量名----从高到低
        //自动转换，-----从低到高
        System.out.println(i);//128
        System.out.println(b);//-128
        System.out.println(c);//128.0

        System.out.println((int)23.7);//23
        char d = 'a';
        int e = d + 1;
        System.out.println(e); // 98
        System.out.println((char) e); //b
    }
}

注意点：
- 不能对布尔值进行类型转换
- 不能把对象类型转换为不相干的类型
- 在把高容量转换到低容量的时候，强制转换
- 转换的时候可能存在内存溢出，或者精度问题
在操作比较大的时候，需要注意溢出问题

public class Demo6 {
    public static void main(String[] args) {
        //操作比较大的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money1 = 1000000000;
        int money2 = 10_0000_0000;
        System.out.println(money1);//1000000000
        System.out.println(money2);//1000000000
        int years = 20;
        long total =money1*years;//-1474836480,计算的时候溢出了
        System.out.println(total);//默认是int，转换之前已经存在问题了

        long total123 = money1*((long)years);//先把一个数转换为long,这样就不会出现问题了
        System.out.println(total123);//20000000000

        //尽量都使用大写的'L'表示long类型，因为小写的'l'容易与'1'搞混掉
    }
}

Java变量、常量、作用域

变量

变量，就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
变量名规范
- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary除了第一个单词以外，后面的单词首字母都大写
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man,GoodMan
- 方法名：首字母小写和驼峰原则：run(), runRun()
注意：
- 每个变量名都有类型，类型可以是基本类型，也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

type varName [=value] [{,varName[=value]}];

public class Demo7 {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=1,b=2,c=3; 要确保程序可读性
        String name="qinjiang";
        char x = 'x';
        double pi = 3.14;
    }
}

变量作用域

public class Demo8 {  //这是定义一个类
    //属性：变量

    //类变量 static
    static double salary = 2500;

    //实例变量：从属于对象;如果不自行初始化，这个类型的默认值
    //所以数值类型初始化默认为：0或0.0
    //布尔值：默认值是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;


    public static void main(String[] args) { //这是类里面的main方法

        //局部变量;有效值在所定义的方法里面;必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型，变量名字
        Demo8 demo8=new Demo8();
        System.out.println(demo8.age);//0
        System.out.println(demo8.name);//null

        //类变量 static
        System.out.println(salary);
    }

    //其他方法
    public void add(){

    }
}

常量

常量：初始化后不能再改变值。不会变动的值
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
常量名一般使用大写字母

//常量的定义
final 类型 常量名=值;
final double PI=3.14;

public class Demo9 {
    //final、static属于修饰符，不存在先后顺序
    static final double PI1 = 3.14;
    final static double PI2 = 3.14;
   
    public static void main(String[] args) {
        System.out.println(PI1);
    }
}

Java基本运算符

Java语言支持如下运算符：下面运算符也具有优先级
- 算数运算符: + - * / % ++ --
- 赋值运算符: =
- 关系运算符:> < >= <= == !=instanceof
- 逻辑运算符: && || !
- 位运算符: & | ^ ~ >> << >>>
- 条件运算符 ?:
- 扩展运算符: += -= *= /=

例1：

package operator;

public class Demo1 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl + D: 复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);//30
        System.out.println(a-b);//-10
        System.out.println(a*b);//200
        System.out.println(a/(double)b);//0.5
    }
}

例2：

package operator;

public class Demo2 {
    public static void main(String[] args) {
        long a = 123123123123123L;
        int b =123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);//Long类型 123123123123264
        System.out.println(b+c+d);//Int  141
        System.out.println(c+d);//Int  18
    }
}

例3：

package operator;

public class Demo3 {
    public static void main(String[] args) {
        // 关系运算符返回的结果: 正确，错误 布尔值
        int a = 10;
        int b = 20;
        int c = 21;
        //取余，模运算
        System.out.println(c%a);//1

        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
    }
}

例4：

package operator;

public class Demo4 {
    public static void main(String[] args) {
        // ++  -- 自增，自减  一元运算符
        int a = 3;
        int b = a++; // 执行完这行代码后，先给b赋值，再自增
        // a++  a = a + 1
        System.out.println(a);
        int c = ++a;// 执行完这行代码前，先自增，再给b赋值

        System.out.println(a);// 5
        System.out.println(a);// 5
        System.out.println(b);// 3
        System.out.println(b);// 3
        System.out.println(c);// 5
        System.out.println(c);// 5

        //幂运算,很多运算会使用工具类进行操作
        double pow = Math.pow(2,3);
        System.out.println(pow);//8.0
    }
}

例4：

package operator;

public class Demo5 {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(b&&a)); // 逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a || b:"+(a||b));// 逻辑或运算：两个变量有一个为真，则结果为ture
        System.out.println("!(a && b):"+!(a&&b));// 如果是真，则变量为假，如果是假则变量为真

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(++c<4);
        System.out.println(d);//false
        System.out.println(c);//5 当&&前一句是假的，则&&后一句就会被跳过，这样就导致了短路
    }
}

例5：

package operator;

public class Demo6 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        ------------------
        A&8 = 0000 1100
        A|B = 0011 1101
        A^B = 0011 0001
        ~B = 1111 0010

        2*8 = 16 2*2*2*2
        效率极高！！！
        << *2
        >> /2

        0000 0000   0
        0000 0001   1
        0000 0010   2
        0000 0011   3
        0000 0100   4
        0000 1000   8
        0001 0000   16
         */
        System.out.println(2<<3);//16
    }
}

例6：

package operator;

public class Demo7 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b; // a = a+b
        a-=b; // a = a-b

        System.out.println(a);

        //字符串连接符 + , 只要元素中有出现字符串，那么就会把其他非字符串元素转换为字符串
        System.out.println(""+a+b);//1020 如果字符串在前会转换字符串
        System.out.println(a+b+"");//30 如果字符串在后则会先进行加法运算在转换成字符串
    }
}

例7：

package operator;

public class Demo8 {
    public static void main(String[] args) {
        // x ? y :z
        // 如果x==true，则结果为y，否则结果为z
        int score = 80;
        String type = score < 60?"不及格":"及格";
        //还可以通过if
        System.out.println(type);//及格
    }
}

Java包机制

先对IDEA进行设置，将compact Middle Packages取消勾选

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

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

一般利用公司域名倒置作为包名www.baidu.com---->com.baidu.www
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可完成此功能

例如：以百度为例子

在开发百度中需要

这样就会出现如下分层视图

导入包

package base;

import base.Demo01

// 导入这个包下所有的类---使用"*"
import base.*

public class Demo9 {
    //final、static属于修饰符，不存在先后顺序
    static final double PI1 = 3.14;
    final static double PI2 = 3.14;

    public static void main(String[] args) {
        System.out.println(PI1);
    }
}

JavaDoc

Javadoc命令是用来生成自己的API文档
参数信息

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

先创建一个Doc的java文件

package com.iyheart.base;

/**
 * @author iyheart
 * @version 1.0
 * @since 1.8
 */
public class Doc {

    String name;

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

在该目录下cmd进入该目录下的终端
然后输入命令 javadoc -encoding UTF-8 -charset UTF-8 Doc.java

执行后就会在当前文件夹下生成了一堆东西

然后点开index.html就会出现如下界面，类似于开发文档这样的

作业：学会查找使用IDEA生成JavaDoc文档

Java流程控制

用户交互Scanner

Java中提供了一个工具类，可以获取用户的输入。java.util.Scanner是Java5的新特征，可以通过该类获取用户的输入
基本语法

1	Scanner s = new Scanner(System.in);

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

package com.iyheart.scanner;

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        //接收用户的输入，并封装为scanner对象
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收：");

        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }
        //使用scanner后需要关闭，否则会占用电脑资源
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();
    }
}
使用next方式接收：
hello world
输出的内容为：hello

使用hasNextLine()接收输入的数据

package com.iyheart.scanner;

import java.util.Scanner;

public class Demo2 {
    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();
    }
}
使用nextLine方式接收：
hello world
输出的内容为：hello world

不做判断，直接接收输入的数据

package com.iyheart.scanner;

import java.util.Scanner;

public class Demo3 {
    public static void main(String[] args) {
        //从键盘接收数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据：");

        // 判断是否还有输入

        String str = scanner.nextLine();
        System.out.println("输出的内容为："+str);
        scanner.close();
    }
}

next():
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
- next()不能得到带有空格的字符串
nextLine():
- 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
- 可以获得空白

Scanner进阶

例子1：

package com.iyheart.scanner;

import java.util.Scanner;

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

        //从键盘接受数据
        int i = 0;
        float f = 0.0f;

        System.out.println("请输入整数：");
        if (scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据："+i);
        }
        else {
            System.out.println("输入的不是整数数据");
        }
        System.out.println("请输入小数：");

        if(scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+f);
        }
        else {
            System.out.println("输入的不是小数数据！");
        }
        scanner.close();
    }
}

示例2

10
20
30
40
x
4个数和为100.0
4个数的平均数是25.0package com.iyheart.scanner;

import javax.sound.midi.Soundbank;
import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少数字
        int m = 0;

        //通过循环判断是否还有输入，并在里面对每一次进行求和统计
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m = m + 1;
            sum = sum + x;
        }
        System.out.println(m + "个数和为" + sum);
        System.out.println(m + "个数的平均数是" + (sum / m));

        scanner.close();
    }
}
10
20
30
40
x
4个数和为100.0
4个数的平均数是25.0

顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构。
语句与语句之间，框与框之间按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

package com.iyheart.struct;

import javax.sound.midi.Soundbank;

public class ShunxuDemo {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}

hello1
hello2
hello3
hello4
hello5

选择结构

if单选择结构
if双选择结构
if多选择结构
嵌套的if结构
switch多选择结构

if单选择结构

很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示
语法

1
2
3

if(布尔表达式){
    //如果布尔表达式为true将执行的语句
}

示例：

package com.iyheart.struct;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        //equals:判断字符串是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}

Hello
Hello
End

if双选择结构

现在有一公司要收购软件，成功了给人支付100万元，失败了，自己找人开发。
这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以有if-else结构
语法：

if(布尔表达式){
	//如果布尔表达式为true
}else{
	//如果布尔表达式的值为false
}

例子：

package com.iyheart.struct;

import java.util.Scanner;

public class IfDemo02 {
    public static void main(String[] args) {
    //考试分数大于60分就是及格，小于60分就是不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩");
        int score = scanner.nextInt();
        if (score > 60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

61
及格
    
56
不及格

if多选择结构

真实的情况存在区间多级判断。比如90-100就是A，80-90就是B等等。
所以出现了多选择结构
语法：

if(布尔表达式 1){
	//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
	//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
	//如果布尔表达式 3的值为true执行代码
}else {
	//如果布尔表达式都不为true执行代码
}

示例：

package com.iyheart.struct;

import java.util.Scanner;

public class IfDemo03 {
    public static void main(String[] args) {
        //成绩分段
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩");
        int score = scanner.nextInt();

        if (score==100){
            System.out.println("恭喜满分");
        } else if (score<100 && score >=90){
            System.out.println("A级");
        } else if (score<90 && score >=80) {
            System.out.println("B级");
        } else if (score< 80 && score >=70) {
            System.out.println("C级");
        } else if (score<70 && score >=60) {
            System.out.println("D级");
        } else if (score<60 && score>=0) {
            System.out.println("成绩不及格");
        }
        else  {
            System.out.println("成绩不合法");
        }

        scanner.close();
    }
}

嵌套的if结构

使用嵌套的if…else语句是合法的。也就是说一个if…else语句里面可以继续使用if…else语句
语法：

if(布尔表达式1){
	//如果布尔表达式 1的值为true执行代码
	if(布尔表达式2){
		//如果布尔表达式 2的值为true执行代码
	}
}

switch多选择结构

多选择结构还有一个实现方式就是switch case语句。
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
switch语句中的变量类型可以是：
- byte、short、int或者char
- 从Java SE 7开始：switch支持字符串String类型
- 同时case标签必须为字符串常量或字面量
语法：

switch(expression){
	case value:
		//语句
	break;//可选
	case value:
		//语句
	break;//可选
	default: //可选
		//语句
}

示例1：要注意case穿透现象，如果没有break，case跳转到相应地方后会出继续执行下方的case和default里面的语句

package com.iyheart.struct;

public class SwitchDemo01 {
    public static void main(String[] args) {
        char grade = 'C';

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

示例2：

package com.iyheart.struct;

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "iyheart";

        switch (name){
            case "aaa":
                System.out.println("aaa");
                break;
            case "iyheart":
                System.out.println("iyheart");
                break;
            default:
                System.out.println("弄啥嘞！");
        }
    }
}

反编译 java—class (字节码文件) — 反编译(IDEA)
在该项目下打开out文件将的SwitchDemo02这里就是字节码文件了

在文件目录下打开是.classs后缀的文件,打开之后是一堆的乱码

反编译后能看到最终case寻找name变量hash加密后的数字

循环结构

while循环
do…while循环
for循环
在Java5中引入了一种主要用于数组的增强型for循环

while循环

while是最基本的循环，它的结构为：

1
2
3

while(布尔表达式){
	//循环内容
}

只要布尔表达式为true，循环就会一直执行下去。
我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方法来结束循环。
少部分情况需要循环一直执行，比如服务器的请求响应监听等。
循环条件一直为true就会造成无限循环（死循环），我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃。
示例1：

package com.iyheart.struct;

public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1~100
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
        }
    }
}

示例2：

package com.iyheart.struct;

public class WhileDemo03 {
    public static void main(String[] args) {
        //计算1+2+3+...+100=?
        int i = 0;
        int sum = 0;
        while (i<=100){
            sum = sum +i;
            i++;
        }
        System.out.println(sum);
    }
}

do…while循环

对于While而言，如果不满足条件，则不能进入循环。但是有时候我们需要即使不满足条件，也至少执行一次
do…While循环和While循环相似，不同的是，do…While循环至少会执行一次
While和do-While的区别：
- While循环先判断后执行。do…While是先执行后判断
- do…while总是保证循环体至少被执行一次
格式：

1
2
3

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

例1：

package com.iyheart.struct;

public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do {
            sum = sum + i;
            i++;
        }while (i<=100);
        System.out.println(sum);
    }
}
# 5050

例2：

package com.iyheart.struct;

public class DoWhileDemo02 {
    public static void main(String[] args) {
        int a = 0;
        while(a<0){
            System.out.println(a);
            a++;
        }
        System.out.println("===============");
        do {
            System.out.println(a);
            a++;
        }while (a<0);
    }
}
#===============
#0

for循环

虽然所有循环结构都可以用while或者do…while表示，但是Java提供了另一种语句——for循环，使一些循环结构变得更简单
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
for循环执行的次数是在执行前就确定的。
注意：
- for循环最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
- 然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句
- 再次检测布尔表达式。循环执行上面过程。
格式

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

//死循环
for(;;)

例1：

package com.iyheart.struct;

public class ForDemo01 {
    public static void main(String[] args) {
        int a = 1; //初始化条件

        while (a<=100){//条件判断
            System.out.println(a);//循环体
            a +=2; // 迭代
        }
        System.out.println("while循环结束！");
        
        for (int i=1;i<=100;i++){
            System.out.println(i);
        }
        System.out.println("for循环结束！");
    }
}

练习1：计算0到100之间奇数和偶数的和

package com.iyheart.struct;

public class ForDemo02 {
    public static void main(String[] args) {
        int i ;
        int sum = 0;

        for(i=0;i<=100;i+=2){
            sum +=i;
        }
        System.out.println("0-100偶数和为"+sum);
        sum = 0;
        for(i=1;i<=100;i=i+2){
            sum = sum+i;
        }
        System.out.println("0-100奇数和为"+sum);
    }
}
0-100偶数和为2550
0-100奇数和为2500

练习2:用while循环或者for循环输出1-1000之间能被5整除的数，并且每行输出3个

package com.iyheart.struct;

public class ForDemo03 {
    public static void main(String[] args) {
        int i;
        int j=0;
        for(i = 1;i<=1000;i++){
            if(i%5==0){
                System.out.print(i+"\t");
                j++;
                if (j%3==0){
                    System.out.println();
                }
            }
        }
        //println 输出完换行
        //print   输出完不换行
    }
}

练习3：打印99乘法表

package com.iyheart.struct;

public class ForDemo04 {
    public static void main(String[] args) {
        int i;
        for(i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+(j*i) + "\t");
            }
            System.out.println();
        }
    }
}

增强for循环

Java5引入了一种主要用于数组或集合的增强型for循环
格式：

for(声明语句 : 表达式)
{
	//代码句子
}

例1：

package com.iyheart.struct;

public class ForDemo05 {
    public static void main(String[] args) {
        int [] numbers = {10,20,30,40,50};//定义了一个数组
        for(int i = 0;i<5;i++){
            System.out.println(numbers[i]);
        }
        System.out.println("=====================");
        //遍历数组的元素
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

break、continue

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

package com.iyheart.struct;

public class BreakDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            if(i==30){
                break;
            }
        }
        System.out.println("123");
    }
}

示例2：

package com.iyheart.struct;

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

关于goto关键字
- goto关键字很早就在程序设计语言中出现。尽管goto仍然是Java一个保留字，但是并未在语言中得到正式使用。
- java没有goto。
- 但是在break和continue上有goto的影子——带标签的break和continue
“标签”：是指后面跟一个冒号的标识符，例如：label：
对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置的标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方
示例3：

package com.iyheart.struct;

public class LabelDemo {
    public static void main(String[] args) {
        //打印101-150之间所以的质数
        int count = 0;
        outer:for (int i=101;i<150;i++){
            for (int j=2;j < i/2;j++){
                if(i%j == 0) {
                    continue outer;
                }
            }
            System.out.println(i+" ");
        }
    }
}

练习

打印三角形

package com.iyheart.struct;

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

        for (int i = 1; i <= 5; 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();
        }
    }
}

debug介绍

在编程过程中可能会出错，这就需要调试，使用debug一步一步调试看看
debug在IDEA的这个位置

先左键点击左边的行数，打下断点，这时候行数就会变成小红点，然后再点击调试按钮

点击调试按钮后，程序就会停在打下断点的位置，然后按下图中红框按钮就会运行一行，这样程序就会一步一步的运行了

Java方法

Java方法是语句的集合，它们在一起执行一个功能（类似于函数）
- 方法是解决一类问题的步骤的有序集合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
设计方法的原则：
- 最好要保证方法的原子性，即一个方法只完成一个功能，这样利于我们后期的扩展
方法的命名规则：参考上面
格式：

修饰符 返回值类型 方法名称(参数1,参数2,参数3,...){
	...
    方法体
    ...
    return 返回值;
}

实际上写的需要这个，一般格式
public static 返回值 方法名称(参数1,参数2,参数3,...){
	...
    方法体
    ...
    return 返回值;
}
// 加入static让其成为类变量,可以直接在main方法里面调用该方法

例1：

package com.iyheart.method;

public class Demo01 {
    // main方法
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
    }
    public static int add(int a,int b){
        return a+b;
    }
}

示例2：

package com.iyheart.method;

public class Demo01 {
    // main方法
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
        test();
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static void  test(){
        for (int i = 0; i <=1000; i++){
            if (i%5==0){
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0){
                System.out.println();
            }
        }
    }
}

方法的定义

Java方法类似于其他语言的函数，用来完成特定功能的代码片段
一般情况下方法的语法：方法包含一个方法头和方法体。
- 修饰符：修饰符，可选，告诉编译器如何调用该方法。定义该方法的访问类型
- 返回值类型：方法可能会返回值。return Value Type是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，return Value Type 是关键字void
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名
- 参数类型：参数像是一个占位符。当方法被调用的时候，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。（Java参数传递都是值传递，没有引用传递）
  - 形式参数：在方法被调用时可用于接收外界输入的数据
  - 实参：调用方法时实际传给方法的数据。
- 方法体：方法体包含具体的语句，定义该方法的功能
示例1：

package com.iyheart.method;

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

    }
    //比大小
    public static int max(int num1,int num2){
        int result = -1; //result必须要初始化一个值
        if (num1==num2){
            System.out.println("num1==num2");
            return 0; //return 0通常表示方法结束，还可以表示返回值是0
        }
        if (num1 > num2) {
            result =  num1;
        }else {
            result = num2;
        }
        return result;
    }
}

IDEA如何查看方法

有时候可能需要查看方法的具体实现
这个时候就可以鼠标先指着方法名，然后按住CTRL就会出现一个下划线，再使用左键点击即可进入一个方法名

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法的重载规则：
- 方法名必须相同。
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
- 方法的返回值类型可以相同也可以不同。
- 仅仅返回值类型不同不足以成为方法的重载
实现原理：
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错
示例1：

package com.iyheart.method;

public class Demo02 {
    public static void main(String[] args) {
        double max = max(10.0,20.0);
        System.out.println(max);
    }
    //比大小---该方法只适用于整数之间比较大小
    public static int max(int num1,int num2){
        int result = -1; //result必须要初始化一个值
        if (num1==num2){
            System.out.println("num1==num2");
            return 0; //return 0通常表示方法结束，还可以表示返回值是0
        }
        if (num1 > num2) {
            result =  num1;
        }else {
            result = num2;
        }
        return result;
    }
    //利用方法的重载实现小数直接的比较大小
    public static double max(double num1,double num2){
        double result = 0; //result必须要初始化一个值
        if (num1==num2){
            System.out.println("num1==num2");
            return 0; //return 0通常表示方法结束，还可以表示返回值是0
        }
        if (num1 > num2) {
            result =  num1;
        }else {
            result = num2;
        }
        return result;
    }
}

示例2：

public static int add(int a,int b){
    return a+b;
}
public static int add(int a,int b,int c){
    return a+b+c;
}

命令行传参

命令行传参：运行一个程序时再传递给它消息。
命令行：命令行的位置如下

编译指令

如果要命令行传递参数的时候，然后就可以进行传参

可变参数

JDK1.5开始，Java支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数类型后加一个省略号（…）
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明
例1：

package com.iyheart.method;

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.test(1);
    }
    public void test(int... i){
        System.out.println(i[0]);
    }
}


package com.iyheart.method;

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.test(1,2,3,4,5);
    }
    public void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
}

例2：

```

```java
public class Demo04 {
    public static void main(String[] args) {
        printMax(34,3,3,2,56.5);
        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);
    }
}

递归

递归就是：A方法调用A方法，自己调用自己
利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
递归的能力在于用有限的语句来定义对象的无线集合
递归结构包括两个部分：
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法
一个错误的示例：会出现栈溢出

package com.iyheart.method;

public class Demo05 {
    public static void main(String[] args) {
        Demo05 test = new Demo05();
        test.test();
    }
    public void test(){
        test();
    }
}

示例2：

package com.iyheart.method;

public class Demo06 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int n){
        if (n==1){
            return 1;
        }
        else {
            return n*f(n-1);
        }
    }
}

作业：

数组

概述

数组是相同类型的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标访问它们

数组声明与创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法

1
2
3

dataType[] arrayRefVar;//首选方法
或
dataType arrayRefVar[]; //效果相同，但不是首选方法

Java语言使用new操作符来创建数组，语法如下：

1 2	dataType arrayRefVar = new dataType[arraySize]; 定义了什么类型的数组就new一个什么类型的数组

数组的元素是通过索引访问的，数组索引从0开始。
获取数组长度：arrays.length
例1：

package com.iyheart.array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        //变量类型 变量名字 = 变量的值;
        //  1.定义———声明一个数组，但是还没分配空间
        int[] nums;
        int nums2[];  //  c/c++风格

        //2.创建一个数组——这里面可以存放10个int类型的数字
        nums = 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;
        System.out.println(nums[9]);

        //计算所以元素的和
        int sum = 0;
        for (int i=0;i<nums.length;i++){
            sum = sum +nums[i];
        }
        System.out.println(sum);
    }
}

数组内存分析

Java内存分析，Java的内存分为，栈、堆、方法区

以数组为例，理解Java内存
- 在创建一个数组的时候，Java先在栈声明一个该数组，但是并没有为该数组开辟空间，也就是说，该数组还不能放东西
- 然后创建数组，这时候就会在堆内存中开辟空间，即可以向数组存放数据。
- 给数组元素赋值就会将值放入堆内存，而不是栈内存中

当数组越界引用的时候Java编译时就会出现报错

1 2	Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 10 at com.iyheart.array.ArrayDemo01.main(ArrayDemo01.java:25)

一般情况下数组的声明和创建会一起进行，如下面语句

1	int[] nums2 = new int[10]

小结：
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds

数值初始化

静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1), new Man(2,2)};

例如：

package com.iyheart.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化：创建+赋值
        int[] a = {1,2,3,4,5,6,7,8};
        System.out.println(a[0]);
    }
}

动态初始化

1
2
3

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

例如：

1
2
3

int[]b = new int[10];
b[0] = 10;
System.out.println(b[0]);

数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组已经分配空间，其中的每个元素也被按照实例变了同样的方式被隐式初始化
数组的四个基本特点：
- 数组的长度确定。数组一旦被创建，它的大小就是不可以改变。
- 其元素必须是相同类型的=，不允许出现混合类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组使用

定义数组

1	int[] arrays = {1,2,3,4,5};

打印全部数组元素

//打印全部数组yaunsu
for (int i = 0; i < arrays.length ; i++){
	System.out.println(arrays[i]);
}

计算所有元素的和

int sum = 0;
for (int i = 0; i < arrays.length; i++){
	sum += arrays[i];
}
System.out.println("sum="+sum);

查找最大元素

int max = arrays[0];
for (int i = 1; i < arrays.length ;i++){
	if (arrays[i] > max){
		max = arrays[i];
		}
}
System.out.println("max="+max);

增强型或循环，适合：打印输出，不适合对数组移动操作等

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        for (int array : arrays){
            System.out.println(array);
        }
    }
}

翻转数组

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;

多维数组

多维数组可以看成数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组
二维数组定义：

1 2	int a[][] = new int[2][5]; // 这个二维数组是可以看成两行五列的数组

例如：

package com.iyheart.array;

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        
    }
}

遍历输出二维数组

package com.iyheart.array;

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

Arrays类

数组的工具类java.util.Arrats

稀疏数组

面向对象

Java的核心思想就是OOP（面向对象编程）
面向过程：
- 步骤简单清晰，知道每一步要做什么
- 面对过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索
- 面向对象时候处理复杂的问题，适合处理需要多人协作的问题
总结：宏观上面向对象，微观上面向过程

面向对象编程

面向对象编程简称OOP
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据
三大特性：
- 封装：包装起来，提供一个进出的口
- 继承：
- 多态
从认识角度考虑：先有对象后与类。对象，具体事物。类，抽象事物，对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模版

方法再学习

方法分为两种，一种是静态方法，另一种是非静态方法
静态方法加了一个关键字后就可以直接引用了，但是非静态方法并不能直接就调用它，这样会导致报错
使用非静态方法就要进行实例化
例子：

package com.iyheart.oop;

public class Demo02 {
    public static void main(String[] args) {
        //实例化这个类 new
        // 对象类型 对象名 = 对像值；
        Student student = new Student();
    }
}

值传递与引用传递：
下面这个是值传递

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

下面这个例子是引用传递
person是一个对象：指向的 —> Person person = new Person();这是一个具体的人，可以改变属性

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); // iyheart
    }
    public static void change(Person person){
        person.name = "iyheart";
    }
}
//定义了一个类，有一个属性：name
class Person{
        String name;
}

类与对象

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但并不代表具体事物
对象是抽象概念的具体实例
例如：
- 操作系统就是一个抽象的概念
- 操作系统中的Windows系统就是一个对象，一个具体的示例
示例：
先添加一个类

package com.iyheart.oop.demo02;

//这是一个学生类
//要养成不要每个类都加main方法，这只是一个单纯的类，而一个程序只有一个main方法
public class Student {
    //一个类里面只有属性和方法
    String name;  // 因为一个类是抽象的，不能String name = "小明"，即不能让类具体化
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

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

package com.iyheart.oop.demo02;

//一个项目只存在一个main方法
public class Applicant {
    public static void main(String[] args) {
        //类：抽象的，实例化的
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体示例
        new Student();
        //这样就可以使用这个类
        Student xiaoming = new Student();
        Student xiaohong = new Student();
		
        System.out.println(xiaoming.name);//null
    }
}

使用类创建了一个对象后就可以给对象赋具体值，因为对象是一个具体的

package com.iyheart.oop.demo02;

//一个项目只存在一个main方法
public class Applicant {
    public static void main(String[] args) {
        //类：抽象的，实例化的
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体示例
        new Student();
        //这样就可以使用这个类
        Student xiaoming = new Student();
        Student xiaohong = new Student();
        xiaoming.name = "小明";
        xiaoming.age = 3;

        System.out.println(xiaoming.name);//null
        System.out.println(xiaoming.age);

        xiaohong.name = "小红";
        xiaohong.age = 3;

        System.out.println(xiaohong.age);
        System.out.println(xiaohong.name);
    }
}
小明
3
3
小红

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。并且构造器有以下俩个特定：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
- 构造器必须掌握
例如：

package com.iyheart.oop.demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    //实例化初始值
    //1. 使用new关键，本质是在调用构造器
    //2. 用来初始化值
    public Person(){

    }
    //有参构造，一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
    // alt + insert生成构造器
    
}

封装

该露的露，该藏的藏
- 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细自己完成，不允许外部干涉；低耦合：暴露少量的方法给外部使用
封装：数据的隐藏
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口访问，这称为信息隐藏
- 封装的关键字是private这样就可以把一个类里面的属性给封装起来，这时候main方法就无法直接引用类里面的属性。如果要引用类里面的属性就必须使用相应类里面的方法设置属性、获取属性等一些列对属性的操作
示例：

package com.iyheart.oop.Demo04;

public class Student {
    //名字
    private String name;
    //学号
    private int id;
    //性别
    private char sex;

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

}

使用main方法调用Student类

package com.iyheart.oop.Demo04;

// 类 private：私有
// 提高程序的安全性，保护数据
// 隐藏代码的实现细节
// 统一接口
//
public class Applicatiho {
    public static void main(String[] args) {
        Student s1 =new Student();
        s1.setName("iyheart");
        s1.getName();
        System.out.println(s1.getName());
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展
- 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的俩个类，一个是子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
- 子类和父类之间，从意义上讲应该具有is a的关系，比如Student is a Person
- 子类可以继承父类的所有方法和属性（需要使用public关键字）如果使用private关键字无法继承
- 四个关键字：子类继承父类一般都用public关键字
  - public
  - default
  - protected
  - private
Java中类只有单继承，没有多继承，在Java中所有的类都默认继承object类
示例1：
先创建了Person类、Student类、Teacher类，在Person类中创建一个方法

package com.iyheart.oop.Demo05;

public class Person {
    public void say(){
        System.out.println("说了一句话");
    }
}


package com.iyheart.oop.Demo05;

public class Student extends Person{
}

package com.iyheart.oop.Demo05;

public class Teacher extends Person{
}

然后再创建一个类，用来使用main方法
- 发现student可以使用say方法，但是say方法在Person类中，这就体现了一个继承的特性

package com.iyheart.oop.Demo05;

public class Applicant {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
    }
}

Java版本管理

安装与使用

参考博客：Windows上的多jdk版本管理工具 - 夜未至 - 博客园 (cnblogs.com)
在github该项目上能解决ystyle/jvms：适用于 Windows 的 JDK 版本管理器（JVMS） (github.com)
具体安装过程如下：
先打开这个链接：发布 ·YSTYLE/JVM (github.com)
选择时候的版本下载，然后解压zip压缩包到想要的路径
然后以管理员权限打开终端（使用jvms都要使用终端管理员才能操作成功），再进入到你解压缩的文件目录下cd E:\app2\Java_manager\jvms_v2.1.6_amd64
打开终端后执行指令.\jvms.exe init，出现如图所示就表示初始化成功，如果不初始化就无法正常使用

常用命令，这边直接抄别人博客了

NAME:
   jvms - JDK Version Manager (JVMS) for Windows
 
USAGE:
   jvms.exe [global options] command [command options] [arguments...]
 
VERSION:
   v2.1.5
 
COMMANDS:
     init        jvms进行初始化
     list, ls    列出本地已经安装的JDK版本
     install, i  安装jdk到本地
     switch, s   切换需要使用的JDK版本
     remove, rm  删除不需要的jdk版本
     rls         列出可以下载的JDK版本
     proxy       使用代理进行下载
     help, h     提供帮助，显示可用的命令

装这个是为了java环境，因为java版本的不同，导致要装各种版本，当时学习Java我装了Jdk8，然后安卓逆向又需要jdk10几的java版本，而之前我的世界的java又需要其他版本，版本不兼容不能切换就很寄，接下来就是利用jvms管理java版本的操作
先创建一个store（名字必须为此）目录，就在jvms.exe所在目录下创建

然后把各种java版本都放到store目录下，这样jvms就能对java版本进行管理了

这样就可以使用命令.\jvms.exe ls，查看到jdk的版本了

先查看当前java版本，这个报错是我是直接移动文件夹，不是复制原理java的文件夹，导致java路径变了，环境变量失效

使用命令将java切换成java19.0.1版本，.\jvms.exe switch java19.0.1，出现如下所示表示切换成功

使用该项目下载其他版本

先使用该命令.\jvms init --originalpath https://raw.githubusercontent.com/ystyle/jvms/new/jdkdlindex.json列出默认情况jdk版本

运行一下JAVA_HOME.\jvms.exe init --java_home "E:\app2\Java_manager\jvms_v2.1.6_amd64\store",这样你之后使用命令行下载jdk的默认路径就在这里了
然后使用该命令.\jvms.exe rls列出能下载的java版本