学习JAVA前的准备

做JAVA的目的

自认为JAVA的学习不算太难，可能以后不会一直从事这样的行业，但是内在的逻辑思维，以及某些时候想要以个人的名义开发一个APP之类的东西的时候就需要编程，而JAVA的适用范围广，有用。且个人认为优先JAVA可能会对我以后如果需要深入学习别的编程会有帮助。
JAVA可以做大数据，云管理系统后台，电商系统平台，桌面工具等实用东西。

写博客的好处

总结思考，提升文笔水平，~~帮助他人~~（如果可以的话）

MARKDOWN

在6.12的文本中

JAVA安装

下载jdk1.8.0原因：1.8.0版本功能已经齐全，方便，没有花里胡哨的东西，大公司一般也是用1.8.0
设置环境变量：这一步对我来说是比较麻烦的一件事，我用的是win7，环境变量和win10系统的不太一样，解决办法：别人教的，找不到了：除了设置好JAVA_HOME【C:\Program Files\Java\jdk1.8.0_291】以外还要设置PATH【C:\ProgramFiles\Java\jdk1.8.0_291\bin;%JAVA_HOME%\bin; 】（PS：大小写不敏感。找到储存JDK的地方，加上\Bin；%JAVA_HOME%\bin;），最后在path前面加上一串东西就可
验证是否完成：控制面板（开始菜单，搜cmd【或者win键+R】打开）输入java,javac,java-version(注意这个小杠杠不用按住shift键)【！！！！！所有的计算机符号输入全部都是英文字符，必须开英文键盘才能打出，比如[ ]\ .......】
配置完成

科普：什么是计算机

分为硬件和软件

硬件：CPU|主板|内存|电源|IO设备（即输入输出设备）\【IO的意思 i:input o:output】

软件：就是APP之类的东西：可以使计算机按照事先预定好的顺序完成特定的功能。

计算机常用快捷键

ALT+F4 关闭所有窗口

Ctrl+C 复制

Ctrl+A 全选

Ctrl+S 剪切

Ctrl+Tab 切换界面

Ctrl+V 粘贴

Ctrl+Z 撤销

Ctrl+S 保存

win+E 我的电脑

ctrl+shift+esc 撤销上一步

Markdown学习

6.11日学习了markdown，现在来复习下学过的内容加紧掌握

加粗：** **

斜线：* *

加粗+斜线*** ***

删除线:
引用：>加空格 回车的作用

我没说过这句话 --鲁迅

生活就像海洋只有意志坚强的人才能到达彼岸（这里开头点了两次回车）

我没说过这句话 --鲁迅

生活就像海洋只有意志坚强的人才能到达彼岸（只点一次回车的效果）
注意插入图片的时候要加！格式：！ [必须是开英文键盘的时候才打得出来] （）外网的最可以，不受到限制

超链接：狂神说比较插入图片来说少了一个感叹号

名字	性别	生日
1	2	0

找到markdow左下角的源代码

重点！！！ DOS命令(大小写不敏感)

盘符切换：直接打CDEF:

直接dir，显示当前盘上所有的文件

cd+空格+输入想进入的目录，切到那个目录

cd_（横杠必须是英文件盘的shift+-）,回到上级目录

md+空格在此处创建目标文件夹

rd+空格删除目标文件夹

cd>+空格+文件名创建一个文件（如：helloworld.java）

del+空格删除文件名

关键字

JAVA中所有组成部分都需要名字
所有的标识符都应该以（A-Z）（a-z）（_）（$）开始
标识符的大小字母敏感的（Hello!=Hello）

习惯类

所有的文件分类号，文件名，编写代码的时候不应该出现中文字符
文件名，编写代码的时候应该使用驼峰结构：首字母小写尔后单词的首字母大写，只有一个单词时可以大写

如（helloWorld.java）
学会速写：psvm,pout等在IDEA的缩写

强类型语言（详）与弱类型语言（略）

强类型语言

要求变量的使用要严格符合规定，所有的变量都必须先定义后才能够使用
JAVA有基本类型（primitive type）和引用类型(reference type)
基本数据类型：有

整数类型：byte short int long

浮点类型：float double (微点：见注1)

浮点数扩展：应试问题：在银行业务中如何表示钱？

问题本质：了解浮点数其实并不准确（即他的离散型与有限性），很多时候在他的浮点类型的范围内会进行向下取整（否则溢出），这时候就要用到Math，BigDecimal这类数据类型，而问题中银行业务需要精确的计算，所以会用到//BigDecimal的数据类型

（注1：）
```
float num1=50.1	F  //F是为了让系统理解我们用的就是float类型而不是double类型
```
字符类型：char

boolean(布尔值)类型：boolean(用于判断是非)（注3）

引用数据类型有类，接口，数组。

布尔值扩展：

（注3：）
```
psvm
float d1 = 232323f;
dloat d2 = d1 + 1;
sout(d1==d2);
//输出结果： false
```
JAVA程序的运行机制

编译型：直接翻译，但更新时需要全部再次翻译，一定情况下省时间，但浪费资源。

解释型：对每一段话都进行翻译，读哪里翻译哪里，如果想回头读则还要再次翻译，性能损失，耗时。

进程

进程：二进制ob 十进制八进制o 十六进制ox

类型转换

1.内存溢出的概念：内存溢出简单说就是超出了数据类型的范围，比如byte只能写0-8，一旦定义的数值或者计算的数值超出这个值，计算就会出错（注4）

、

注4：
```
psvm
  byte b = 100;
  sout(b)；
//输出：-100
```
2.强制转换：强制转换的目的就是让目标不内存溢出，格式（类型）变量名（注五）

（tips：如果是；两个类型不一样的值进行运算，则默认将两个类型的变量转化成类型int再计算）

注五：
```
psvm
  byte b = 100;
  sout((long)b)；
//输出：100
```
注意事项：
1. 不能对布尔值进行转换
2. 不能把对象类转化为不相干的类型
3. 在把高容量转换成低容量类型时不需要也不能使用强制转换，IDEA会报错，因为电脑会自动帮你转换（由低到高：byte<short<char<int<long<float<double）
4. 转换时也能出现内存溢出或者精度问题
5. 电脑优先在上一类型内进行运算，再输出的时候转换成想要输出的类型。注6
注6：
```
psvm
  int money=1000000//这一步已经出现了问题
  int years=20
  long total= money * years
  	sout
  	//输出错误答案
```
(微点：JDK7以上的特性，在数字之间可以用英文键盘下的下划线分割，不会对数字产生影响，便于观察)

JAVA SE

关键字，关键词，数据类型等

标识符与关键字：JAVA所有的组成成分都需要
名字，类名，变量名以及方法名都被称作标识符
1. 数据类型，分为int,short,type,long,数字类型double,float浮点类型
  boolean布尔值为三类，还有char字符类型，字符！=字符串，字符只有单个，而且需要
  引用字符时，格式A='狂'。
2. 强转：强转只需要高转低，低转高是自动转换，布劳费心。
  从高到低：double>float>long>type>int>short无关不能强转：比如char类型转成float。
3. 如果两个数的数据类型不一样的话，JAVA会优先将他们转成int类型再计算。
变量：
数据类型变量名 =值；
运算符号
有：+ - * /(加减乘除) %（求余） ++ -- （自增减）
逻辑运算符： &&（且） ||(或) !（非）
三元？？运算符： > ? ： (判断，如果是对的，则执行？之后的语句，否则就折行：之后的语句)

//判断 a++ 与 ++a 的 区别以及 >?= 的用法
class Demo01;
public static void main(String args[]){
      int a = 2;
        int b;
        System.out.println(a);  // a：2
        b=a++;
        System.out.println(b);  // b:2
        //先赋值再自增，先让b=a，再a++
        b=++a;
        System.out.println(b);  // b:4
        //先自增再赋值，即先a++，再b=a
        System.out.println("==================================");
        int c = 2;
        while (c<5){
            System.out.print(c+"\n");  //最终输出 2 3 4 5
            c++;
        }
        System.out.println("===================================");
        int d = 2;
        while (d<5){
            d++;
            System.out.print(d+"\n");  //最终输出3 4 5 6
            String grade = a<3 ? "不及格" : “及格”;
			System.out.println(grade)  //最后输出：”不及格“
        }
    }
}

一些用在 System.out.println() 上的？

\n换行输出相当于println里的ln 。

\t 空格，相当于在（）里填写“ ”。

括号开头增加双引号使得输出语句内不再运算而是全部打印出来（详看以下部分代码）
```
int a = 2;
int b = 3;
System.out.println(a+b);  //输出 5
System.out.println(""+a+b);  //输出  23
```

代码

if 结构：如果需要两种以上的判断时，可以使用else if，否则else就够了

package Demo01;

public class Demo05 {
    public static void main(String[] args) {
//test 1: use IF to select ones grade.
        int a= 60;
        if (a>60){
            System.out.println("well");
        }else if (a==60){
            System.out.println("bad");
        }else if (a<60||a>0){
            System.out.println("worst");
        }else{
            System.out.println("error");
        }

DoWhile 和 While 的区别：有时候我们需要程序尽管判断时已经出错但仍然要运行一次时，要使用DoWhile结构，注意格式do写代码while跟判断

package Demo01;
public class Demo05 {
    public static void main(String[] args) {
 //distinguish "DoWhile" and"While"
        while(a!=60){
            a++;
            System.out.println(a);
        }
        do {      a++;
            System.out.println(a);
        } while(a==0);
    }

Switch 结构 + break & continue ：

break：完成这句话之前以及{}之内的任务后立即跳出循环，并且结束循环

continue：完成这句话之前以及{}之内的任务后立即跳出循环，进入下一次循环

    char grade ='C';
        switch(grade){
            case 'A':
                System.out.println("perfect");
                break;
            case 'B':
                System.out.println("good");
                break;
            case 'C':
                System.out.println("bad");
                break;
            case'D':
                System.out.println("worst");
                break;
            default:
                System.out.println("unknown word");

continue 详解

//task:打印1-100所有可以被5整除但是要排除可以被10整除的数。
package Demo01;

public class Demo06 {
    public static void main(String[] args) {
        for(int i = 0;i<100;i++){
            if(i%5==0){
                if(i%10==0){
                    continue;
                }else{System.out.print(i+"\t");
                }
            }
            else{
                continue;
            }
        }
    }
}
//输出：5 15 25 35 45 55 65.....95

课堂任务：初步了解算法思维与用法

task1：打印九九乘法表

task2：打印三角形

public static void mian (String[] args){
    //打印九九乘法表
  for(int a=1;a<=9;a++){
      for(int b =1;b<=a;b++){
          System.out.print(a+"*"+b+"="+"a*b"+"\t");
      }
      System.out.println();
  }  
}
//灵活运用循环解决一些有规律的问题

package Demo01;
//打印一个三角形
public class Demo08 {
    public static void main(String[] args) {
        for (int a = 1; a <=5; a++) {
            for (int b = 5; b>=a; b--) {
                System.out.print(" ");}
                for (int c = 1; c <=a; c++) {
                    System.out.print("*");
                }
                for (int i = 1; i <=a-1; i++) {
                    System.out.print("*");
                }
            System.out.println();

2022年7月14日 JAVA SE补充

包机制（用ideal写class文件为例）

可以将自己写的各种文件联系在一起，相当于C语言新建一个项目
命名规则：一个网址的域名翻转，如百度（www.baidu.com）
创建的文件应该是com文件夹包含baidu文件，baidu文件又包含com文件，然后在某个分支写class文件.

scanner的运用

scanner是JAVA程序中用户与程序交互的方法，通过scanner来输入字符，暂时记住以下格式


    public static void main(String[] args)
    {
        //...(前置格式)
        Scanner scanner = new Scanner(System.in); 
        //新建一个接收器
        if(scanner.hasNextLine())
        //判断接收器内是否存在字符串
        {
            String str =  scanner.nextLine();
            //如果有，将接受器内的回车之前的内容
            //赋值给字符串变量str中
        }       

        //....（输出验证）
        scanner.close();
        //与IO流有关的方法一定要在使用完毕后关闭，
        //避免方法一直抢占资源
    }

但注意接收器的变化，一旦接收器读取到了对应的节点，接收器就不会再给变量赋值，接收器有剩余时不会主动清除，因此会影响之后接收器给下一个变量赋值的结果。

方法

方法简述

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

方法包含在类或者对象中

方法在程序中被创建，在其他地方被引用。

设计方法的原则：一个方法只完成一个功能，利于后期扩展
by 狂神说Java


public class Demo01
{
    public static void main(String[] args)
    {
        int x;
        x = add(1,2);
        System.out.println("1+2="+x);
    }
    //main方法，每个class文件必备的方法

    public static int add(int x,int y)
    {
        int z;
        z = x+y;
        return z;
    }
    /*
    方法格式：
    public static 修饰词，为方法提供一些限制
    void 返回值的变量类型
    add 方法名,名字可以随便取
    */

}

总结：java就是一个方法的结合体任何java程序都离不开方法

方法的重载

java的一种特性，方法的名字可以一样，但他们的引用参数的数据类型不可以一样，优势在于在进行一个名字的方法时，有时不能确定变量的类型，通过重载，可以通过虚拟机自动判断你用的是哪个方法，即使他们是同名，C语言就没有这样的便利。

可变参数

java方法的特性，方法的重载难以满足另一种可能性：不确定需要传递多少参数，则可以使用可变参数：
格式：修饰词+方法名（不可变参数，可变参数）
可变参数： int i...

public static int add(int x,int y...)

方法的递归

递归可以用于解决很多复杂问题，内核是通过有限的反复调用自身来获得运算。
理解：因为方法可以被方法调用，所以方法可以调用自己（自己也是一种方法）
狂神说java 课例

public class Demo01
{
    //初始化
    //问题：求5！ .
    public static void main(String[] args)
    {
        //语句：输出f(5)
    }

    public static int f(int n)
    if(n!=1)
    {
        return n*f(n-1);
        //如果n不是1，那个乘以进行方法f(n-1)再乘以n, 
    }
    else
    {
        return 1;
    }

}

方法的调用

静态方法的调用(可以调用不同类文件中的方法)：方法所在类.方法
（和非静态方法相比，多一个static少一句实例化语句）
非静态的方法，要实例化这个类。

//实例化过程
Student student = new Student();
student.says();
//变量类型 对象名 = 对象值

引用传递与值传递

应用传递实质就是值传递

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

    public static void change(Person person)
    {
        String name//=null;
    }
}

有修饰词static的对象和类一起加载的

2022年7月15日

数组

数组格式

int num[];//声明一个数组
num = new int[10];//创建，分配初始大小
//==============
int[] num = new int[10];
//两种都可以，但是建议使用第二种，这是java的写法，第一种写法是c/c++的写法

内存分析和初始化

内存分析

java内存堆，栈，
堆存new（内存），栈存名

静态初始化(创建+赋值)

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

动态初始化

int[] b = new int[10];
//所有值都是0/null(char，string类型)

知识回扣：堆栈与new

想要使用一种变量，有两种写法，就是数组大章写的动态与静态数组的创建，或是单个数据类型。与C语言创建一个变量有比较大差别的是：java还多出了一个给变量规定内存大小的位置。

数组的使用

做题：

写出一个数组，其中有1，2，3，4，5五个数，利用for循环求和。
写一个数组，有1,2,3,4,5五个数，利用for循环输出逆序的数组，并且将数组反转。

类与对象的关系

首先规定规范：一个工程只能有一个main类

类和对象的关系：类是一个抽象的概念，对象就是以类为模板，创造出一个有实际属性的内容。

例如：我认为student是一个类，这个类会有名字和年龄两个属性，我创建(new)一个新的学生，取名为小红，12岁。这就是一个新的对象，我还可以创建一个学生小明，13岁。这些都是以student类为模板，才创建出不同属性但属于学生类的两个对象

有修饰词static的对象和类一起加载的

创建与初始化对象

一个类即使什么都不写，也会有一个构造方法

构造器：构造器的名字和类名一致且没有返回值。

构造器的用法：

使用new关键字，本质是在调用构造器。
实例化初始化。

构造器例子：

//main类
package hws;

public class exercise
{
    public static void main(String[] args) {
        Constructor con = new Constructor("hws");
        Constructor con1 = new Constructor();
        System.out.println(con.Name);
        System.out.println(con1.Name);
    }
}

//constructor类
package hws;

public class Constructor {
    String Name;
    public Constructor()
    {
        this.Name = "No name";
    }
    //构造器：和类名字相同，用于初始化，本质上是new调用的内容，
    // 之前一直使用的是类似这种的无参构造
    public Constructor(String name)
    {
        this.Name = name;
    }//这样属于有参构造
}

多维数组(略，书写方法见知识回扣)

Arrays 类

shift+enter指定arrays类可以看到所有的arrays方法
课例：

import java.util.Arrays;

int[] a={1,2,3,4};
System.out.println(Arrays.toString(a));

//输出[1,2,3,4]

在平时善于使用方法来简化计算。

冒泡排序（重要）

详见C语言，简单描述，可以记忆

int num[6]={...};
for(int i=1;i<6;i++)
{
    for(int j=0;j<6-i;j++)
    {
        //....;
    }
}

口诀：排列n个数，要排n-1层，第m层要排n-m次

稀疏数组

课例：编写五子棋游戏中，有存盘退出和续上盘的功能。
稀疏数组：当一个数组中大部分元素为0，或者为统一值的数组时，可以使用稀疏数组来保存数组。
处理方式是：记录数组一共有几行几列，有多少个不同值
把具有不同值元素和行列以及值记录在一个小规模的数组中，从而缩小程序的规模
比如：

行	列	值
11	11	2
1	3	1
2	3	2

其中，若上面的表格记录一个稀疏数组，第一行数为原数组的行列数和所有值的个数。下面再遍历出所有点的行列以及值，这就是压缩后的数组

========(今日作业)

面向对象编程

认识面向对象
方法回顾和加深
对象的创建分析
面向对象的三大特性
抽象类和接口
内部类以及OOP实战

面向过程和面向对象

面向过程思想

步骤清晰简单，第一步做什么，第二部做什么

比较适合处理一些较为简单的问题

面向对象思想

物以类聚，分类思想，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索

面向对象适合处理复杂的问题，适合处理需要多人协作的问题

可以说，面向对象就是一种管理与分配任务的方式，本质上还是需要面向过程来制作，不客观的说面向对象包含面向过程

什么是面向对象（Object-Oriented-Programming，OOP）

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

三大特性：

封装，继承，多态

======
2022.7.18

封装（p67）

追求高内聚，低耦合，

类的内部操作细节自己完成，不允许外部干涉。
尽量暴露少量的方法给外部使用

对于封装：属性私有，get/set

封装的意义：

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

继承（关键字：extends 类）

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

Java中类只有单继承，没有多继承
继承是类和类之间的一种关系。除此之外，雷和类的关系还有依赖，组合，聚合等

public class Father
{
    String name = "Qing";
}

public class Son extends Father
{
    String num=1;
}

public class DEMO01
{
    Son son = new Son();
    System.out.println(son.name);
}

super

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

this

本身调用者这个对象
没有继承也可以使用

方法的重写

重写只和非静态的方法有关
重写的关键词是static
只能子类重写父类的方法，属性不可改
方法名必须相同，方法体不同
修饰符：范围可以扩大，但是不能缩小，比如说父类是private，子类就可以写成public
抛出的异常：范围，可以被缩小，但不能扩大：

为什么需要重写

父类的功能子类不一定需要，或者不一定满足！
AIT + INSERT :override

多态

即统一方法可以根据发送对象的不同采用多种不同的行为方式

多态是方法的多态
父类和子类有联系

多态怎么理解

如果用子类重写父类时，子类和父类同名的方法将运行子类的方法。这样就相当于一种名字的方法在不同的需求中有不同的运行方式，叫做多态。

注意：多态是方法的多态，属性没有多态。

关键字instanceof(类型转换) 引用类型，判断一个对象是什么类型

System.out.println(object instanceof Student);
//如果两个类型不是父子关系会报错

注意：
1、比如Person X = new Student()，我们知道左边Person是引用类型，右边Student是实际类型
2、X instanceof Y，然后看X的类型（就是引用类型Person）和Y有没有继承关系，没有就直接报错，有就下一步
3、然后判断X的实际类型（就是右边的Student），是不是Y本身或者他的子类，是就true，不是就false
4、注意的是实际类型不能是Y的父类，不然就会fals（引用自视频下用户弹幕笔记，侵权删）

强制转换

Person student = new Student();
//引用父类的方法，新建一个子类（运行时采用大部分父类的方法，如果父子类有重名方法则运行子方法）
((Student)student).method();
//将设method方法是子类特有的方法因为student引用的类是person，没有method方法，所以要以这种格式将student对象强转为Student方法。这样才能引用成功，否则报错

需要注意的是：子类转化为父类时，可能丢失自己本来的一些方法，丢失的方法是子类有但是父类没有的这些方法？？

static 关键字详解

static 为静态变量，非静态的方法可以调用所有静态的方法。因为静态变量会预加载。

abstract 抽象类关键字详解

在一个类里加这个关键字，这个类就是抽象类

abstract 是约束类，只给与方法的约束，只有类的名字，没有具体的方法

要求

不能在别的方法new这个抽象类，因为其本身并不完整
抽象类里面可以写不同方法，但一旦类中存在抽象方法，那么这个类必须是抽象类。（即抽象=未完成的工作）

意义：
抽象公用属性，提升开发效率

接口（关键字：interface）

普通类：只有具体表现
抽象类：具体实现和规范（抽象方法）
接口：只有规范，自己无法写方法~专业的约束！约束和实现分离：面向接口编程

实现了接口的类，就需要重写接口中的方法。
作用：

约束
定义一些方法，让不同的人实现
public abstract
public static final
接口不能让被实例化，接口中没有构造方法
implements可以实现多个接口
必须要重写接口中的方法

N种内部类

内部类就是在一个类的内部在定义一个类,内部类可以调用外部类的私有属性。

public class Outer
{
    public void out()
    {
        System.out.println("外部类");
    }

    class Inner()
    {
        public static void in()
        {
        System.out.println("内部类");
        }
    }
}

public class demo01
{
    public static void main(String[] args)
    {
        Outer.Inner inner = new Outer;
        inner.in();
    }

    //输出：内部类。
}

注：一个java类可以有多个class类但是只能有一个public class 类。

异常机制

什么是异常

程序没办法按照自己的意愿运行。
检查性异常：程序员无法预见
运行时异常：可以避免

异常处理机制

抛出异常和捕获异常
五个关键字 try

int i=1;
int j=0;
try
{
    sout(i/j);
//监控区。有异常可以捕获到
}catch(ArithmeticException e)
{
    //捕捉到上述异常后执行以下语句：捕获异常，可以多重catch,但异常要从细节写到粗略。
    sout("程序出现异常，变量b不能为0");
}finally
{
    //无论异常与否，这句话必出
    sout("finally");
}

   //假设这个方法中，处理不了这个异常，方法上抛出异常
if(b==0)
{
    throw new ArithmeticException();
    //主动的抛出异常，一般在方法中使用
}

Ctrl + ait + T:快速创建抛出异常方法

自定义异常（用处小）

创建自定义异常类
写一个类，继承exception类，即为自定义异常类

alt + enter?/insert:处理异常

多线程学习

多线程的认识：多线程，指多个进程同时进行，但cpu只有一个，所谓的多线程实际上也是一个一个加载，只不过他以极快的速度切换进程运行，尽量保持全部的进程都又被关注到。

public class demo01 {

    public static class newThread extends Thread
    {
        public void run()
        {
            for(int i=0;i<20;i++)
            {
                System.out.println("HWSHWS---"+i);
            }
        }


    public static void main(String[] args)
    {
        newThread newthred = new newThread();

        newthred.start();
        for(int i=0;i<20;i++)
        {
            System.out.println("SWHSWH---"+i);
        }
    }

    }
}
/*
自己写的时候遇到的小问题：
1. 如果要直接使用class文件对应的类名继承Thread，这个类不能被静态static关键字修饰，反之，如果是class文件对应的类名内书写的新类继承Thread,则必须要使用静态关键字修饰。
2. 注意继承的类的括号内要包含main类。（至少目前为止）
*/

runnable接口

实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法

package constructor;

public class runnable_demo implements Runnable{

    @Override
    //重写的标志，书写继承runnable的类必须重写run();
    public void run() {
        int i;
        for (i=0;i<200;i++)
        {
            System.out.println("A"+i);
        }
    }


    public static void main(String[] args) {
        runnable_demo demo = new runnable_demo();
        Thread th = new Thread(demo);
        th.start();
        //一般简写成new Thread(demo,"名字在需要的时候写").start();

        for (int i = 0; i < 100; i++) {
            System.out.println("B"+i);
        }

    }

}

要使用多线程，一定要以start方法开始，这是开始的标志

龟兔赛跑-Race

package constructor;
//这个案例以狼与兔子为例子
public class race implements Runnable{
//设立一个winner,唯一，以便输出最终获胜的人
    private static String winner;
    public void run()
    {
        for (int i = 0; i <= 100; i++)
        {
            if(Thread.currentThread().getName().equals("wolf")&& i%10==0)
            //Thread.currentThread().getName().equals("wolf")的方法，确定方法的名字是否一致，一致则输出true.
            {
                try {
                    Thread.sleep(2);//休眠2毫秒，模拟狼休息的时间
                    //并且尝试用try来抛出运行时错误
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

            boolean flag = gameover(i);//复习，布尔值的值为true或者faluse
            if(flag)
            {
                break;
            }

            System.out.println(Thread.currentThread().getName()+" has run "+i+" m");
        }
    }
    //判断是否完成，如果没有完成任务（1.没有确定胜者）或者任务完成，但2. 已经有人达到了100步，提取那个到达100的人名

    private boolean gameover(int steps)
    {
        if(winner!=null)
        {
            return true;
        }
        if (steps==100) {
            winner = Thread.currentThread().getName();
            System.out.println("Winner is " + winner);
            return true;
        }

        return false;
    }

    public static void main(String[] args) {
       race Race = new race();

       new Thread(Race,"rabbit").start();
       new Thread(Race,"wolf").start();
    }
}

实现Callable接口（了解即可）

区别：

重写方法call具有返回值
还有

创建执行服务
提交执行
获取结果
关闭服务


ExecutorService ser = Executors.newfixedThreadPool(3);
//3:执行三个线程。（创建执行服务）

Future<Boolean> r1 = ser.submit(t1);
Future<Boolean> r2 = ser.submit(t2);
Future<Boolean> r3 = ser.submit(t3);
//提交执行

boolean rs1 = r1.get();
boolean rs2 = r1.get();
boolean rs3 = r1.get();
//获取结果

ser.shutdown();
//关闭服务

好处：

可以定义返回值
可以抛出异常

静态代理

posted on 2022-07-14 14:45 ୯Aliza୬ 阅读(30) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 前端学习：html篇+CSS（连载中）

· JAVA基础

· 自学JAVA第五天：面向对象

· 1-java零基础学习视频通俗易懂

· Java核心面试知识集—Java基础知识面试题

୯Aliza୬

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜