学习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
注意事项:
-
不能对布尔值进行转换
-
不能把对象类转化为不相干的类型
-
在把高容量转换成低容量类型时不需要也不能使用强制转换,IDEA会报错,因为电脑会自动帮你转换(由低到高:byte<short<char<int<long<float<double)
-
转换时也能出现内存溢出或者精度问题
-
电脑优先在上一类型内进行运算,再输出的时候转换成想要输出的类型。注6
注6:
psvm int money=1000000//这一步已经出现了问题 int years=20 long total= money * years sout //输出错误答案
(微点:JDK7以上的特性,在数字之间可以用英文键盘下的下划线分割,不会对数字产生影响,便于观察)
-
JAVA SE
关键字,关键词,数据类型等
-
标识符与关键字:JAVA所有的组成成分都需要
名字,类名,变量名以及方法名都被称作标识符 -
-
数据类型,分为int,short,type,long,数字类型double,float浮点类型
boolean布尔值为三类,还有char字符类型,字符!=字符串,字符只有单个,而且需要
引用字符时,格式A='狂'。 -
强转:强转只需要高转低,低转高是自动转换,布劳费心。
从高到低:double>float>long>type>int>short无关不能强转:比如char类型转成float。 -
如果两个数的数据类型不一样的话,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();
//关闭服务
好处:
- 可以定义返回值
- 可以抛出异常
【推荐】国内首个AI IDE,深度理解中文开发场景,立即下载体验Trae
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 阿里最新开源QwQ-32B,效果媲美deepseek-r1满血版,部署成本又又又降低了!
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决:字节Trae VS Cursor,谁才是开发者新宠?
· 开源Multi-agent AI智能体框架aevatar.ai,欢迎大家贡献代码
· Manus重磅发布:全球首款通用AI代理技术深度解析与实战指南