୯Aliza୬

博客园 首页 新随笔 联系 订阅 管理
  3 随笔 :: 0 文章 :: 0 评论 :: 100 阅读

学习JAVA前的准备

做JAVA的目的

  1. 自认为JAVA的学习不算太难,可能以后不会一直从事这样的行业,但是内在的逻辑思维,以及某些时候想要以个人的名义开发一个APP之类的东西的时候就需要编程,而JAVA的适用范围广,有用。且个人认为优先JAVA可能会对我以后如果需要深入学习别的编程会有帮助。

  2. JAVA可以做大数据,云管理系统后台,电商系统平台,桌面工具等实用东西。

写博客的好处

总结思考,提升文笔水平,帮助他人(如果可以的话)

MARKDOWN

在6.12的文本中

JAVA安装

  1. 下载jdk1.8.0原因:1.8.0版本功能已经齐全,方便,没有花里胡哨的东西,大公司一般也是用1.8.0

  2. 设置环境变量:这一步对我来说是比较麻烦的一件事,我用的是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前面加上一串东西就可

  3. 验证是否完成:控制面板(开始菜单,搜cmd【或者win键+R】打开)输入java,javac,java-version(注意这个小杠杠不用按住shift键)【!!!!!所有的计算机符号输入全部都是英文字符,必须开英文键盘才能打出,比如[ ]\ .......】

  4. 配置完成

科普:什么是计算机

分为硬件和软件

硬件: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. 引用:>加空格 回车的作用

    我没说过这句话 --鲁迅

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

    我没说过这句话 --鲁迅

    生活就像海洋只有意志坚强的人才能到达彼岸(只点一次回车的效果)

  3. 蕾姆

    注意插入图片的时候要加! 格式: ! [必须是开英文键盘的时候才打得出来] ()外网的最可以,不受到限制

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

名字 性别 生日
1 2 0

找到markdow左下角的源代码

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

盘符切换:直接打CDEF:

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

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

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

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

rd+空格 删除目标文件夹

cd>+空格+文件名 创建一个文件(如:helloworld.java)

del+空格 删除文件名

关键字

  1. JAVA中所有组成部分都需要名字

  2. 所有的标识符都应该以(A-Z)(a-z)(_)($)开始

  3. 标识符的大小字母敏感的(Hello!=Hello)

习惯类

  1. 所有的文件分类号,文件名,编写代码的时候不应该出现中文字符

  2. 文件名,编写代码的时候应该使用驼峰结构:首字母小写尔后单词的首字母大写,只有一个单词时可以大写

    如(helloWorld.java)

  3. 学会速写:psvm,pout等在IDEA的缩写

强类型语言(详)与弱类型语言(略)

强类型语言

  1. 要求变量的使用要严格符合规定,所有的变量都必须先定义后才能够使用

  2. 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

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

  1. 标识符与关键字:JAVA所有的组成成分都需要
    名字,类名,变量名以及方法名都被称作标识符

    1. 数据类型,分为int,short,type,long,数字类型double,float浮点类型
      boolean布尔值为三类,还有char字符类型,字符!=字符串,字符只有单个,而且需要
      引用字符时,格式A='狂'。

    2. 强转:强转只需要高转低,低转高是自动转换,布劳费心。
      从高到低:double>float>long>type>int>short无关不能强转:比如char类型转成float。

    3. 如果两个数的数据类型不一样的话,JAVA会优先将他们转成int类型再计算。

  2. 变量:
    数据类型 变量名 =值;

  3. 运算符号

  4. 有:+ - * /(加减乘除) %(求余) ++ -- (自增减)
    逻辑运算符: &&(且) ||(或) !(非)
    三元??运算符: > ? : (判断,如果是对的,则执行?之后的语句,否则就折行:之后的语句)

//判断 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)  //最后输出:”不及格“
        }
    }
}
  1. 一些用在 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
    
    

代码

  1. 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");
        }
  1. DoWhileWhile 的区别:有时候我们需要程序尽管判断时已经出错但仍然要运行一次时,要使用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);
    }
  1. 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. 写出一个数组,其中有1,2,3,4,5五个数,利用for循环求和。
  2. 写一个数组,有1,2,3,4,5五个数,利用for循环输出逆序的数组,并且将数组反转。

类与对象的关系

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

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

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

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

创建与初始化对象

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

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

构造器的用法:

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

构造器例子:

//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)

追求高内聚,低耦合

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

对于封装:属性私有,get/set


封装的意义:

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

继承(关键字:extends 类)

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

  1. Java中类只有单继承,没有多继承
  2. 继承是类和类之间的一种关系。除此之外,雷和类的关系还有依赖,组合,聚合等
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

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

this

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

方法的重写

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

为什么需要重写

  1. 父类的功能子类不一定需要,或者不一定满足!
  2. AIT + INSERT :override

多态

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

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

多态怎么理解

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


注意:多态是方法的多态,属性没有多态。

关键字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 是约束类,只给与方法的约束,只有类的名字,没有具体的方法

要求

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

意义:
抽象公用属性,提升开发效率

接口(关键字:interface)

普通类:只有具体表现
抽象类:具体实现和规范(抽象方法)
接口:只有规范,自己无法写方法~专业的约束!约束和实现分离:面向接口编程

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

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

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:快速创建抛出异常方法

自定义异常(用处小)

  1. 创建自定义异常类
  2. 写一个类,继承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接口(了解即可)

区别:

  1. 重写方法call具有返回值
  2. 还有

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


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();
//关闭服务

好处:

  1. 可以定义返回值
  2. 可以抛出异常

静态代理

posted on   ୯Aliza୬  阅读(30)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 阿里最新开源QwQ-32B,效果媲美deepseek-r1满血版,部署成本又又又降低了!
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决:字节Trae VS Cursor,谁才是开发者新宠?
· 开源Multi-agent AI智能体框架aevatar.ai,欢迎大家贡献代码
· Manus重磅发布:全球首款通用AI代理技术深度解析与实战指南
点击右上角即可分享
微信分享提示