我在上海乐字节学习java的第十一天（持续更新中）

包

1. 对文件进行分类管理（当类文件名相同时）
2. 对类提供多层命名空间
3. 写在程序文件的第一行
4. 类名的全程是报名.类名
5. 包也是一种封装形式

package lesson11;//包可以多层嵌套
import java.util.Arrays;//为了简化类名的书写
public class test1 {
   public static void main(String [] args){
       int[] arr=new int[]{1,2,45,4,5,23,7,8};
       //打印数组
       String res=Arrays.toString(arr);
       System.out.println(res);
       //数组排序
       Arrays.sort(arr);
       res=Arrays.toString(arr);
       System.out.println(res);
   }
}

也可以这么写

package lesson11;//包可以多层嵌套
public class test1 {
   public static void main(String [] args){
       int[] arr=new int[]{1,2,45,4,5,23,7,8};
       //打印数组
       String res=java.util.Arrays.toString(arr);
       System.out.println(res);
       //数组排序
       java.util.Arrays.sort(arr);
       res=java.util.Arrays.toString(arr);
       System.out.println(res);
   }
}
<<<
[1, 2, 45, 4, 5, 23, 7, 8]
[1, 2, 4, 5, 7, 8, 23, 45]

结果是一样的

jar包

Jar :java的压缩包 我用的是idea下边演示一下idea怎样打JAR包

选取主类

多线程

进程：正在进行中的程序。（当然这么说太直接了）

线程：就是进程中一个负责程序执行的控制单元。（执行路径）

一个进程中可以有多个线程，称为多线程。

开启多个线程是为了同时运行多个代码，每一个线程都有自己运行的代码，这个内容可以称为线程要执行的任务。

多线程存在哪些弊端？ windows看起开是同时执行了多任务，但是其实不是，只是执行任务切换比较快（时间片）,当线程太多效率就会降低。

在java虚拟机中，有一个线程在执行主线程，还有个一线程进行GC，jvm中实现了多线程。

package lesson11;
public class test2 {
   public static void main(String []args){
       new Demo();
       new Demo();
       System.gc();//调用gc，调用对象的finalize回收方法
       new Demo();
       System.out.println("Hello world");
   }
}
class Demo extends Object{
   public void finalize(){
       System.out.println("ok");
   }
}
<<<
ok
Hello world
ok

单线程

package lesson11;
public class test2 {
   public static void main(String []args){
       Demo d1 = new Demo("d1");
       Demo d2 = new Demo("d2");
       d1.show();
       d2.show();
   }
}
class Demo {
   private String name;
   Demo(String name){
       this.name = name;
   }
   public void show(){
       for(int x=0;x<10;x++){
           System.out.println(name+"``"+x);
       }
   }
}
<<<
d1``0
d1``1
d1``2
d1``3
d1``4
d1``5
d1``6
d1``7
d1``8
d1``9
d2``0
d2``1
d2``2
d2``3
d2``4
d2``5
d2``6
d2``7
d2``8
d2``9

创建线程

创建线程的第一种方式：

1. 定义一个类继承Thread类
2. 覆盖run方法
3. 启动线程对象的start方法

package lesson11;
public class test3 {
   public static void main(String [] args){
       MyThread a = new MyThread("Thread_a");
       MyThread b = new MyThread("thread_b");
       a.start();
       b.start();
   }
}
class MyThread extends Thread{
   private String name;
   MyThread(String name ){
       this.name = name;
   }
   @Override
   public void run() {
       for(int i =0;i<10;i++){
           System.out.println(name+"-------"+i);
       }
   }
}
<<<
Thread_a-------0
thread_b-------0
Thread_a-------1
thread_b-------1
Thread_a-------2
thread_b-------2
Thread_a-------3
thread_b-------3
Thread_a-------4
Thread_a-------5
thread_b-------4
Thread_a-------6
Thread_a-------7
thread_b-------5
thread_b-------6
Thread_a-------8
thread_b-------7
thread_b-------8
thread_b-------9
Thread_a-------9
package lesson11;
public class test3 {
   public static void main(String [] args){
       MyThread a = new MyThread("Thread_a");
       MyThread b = new MyThread("thread_b");
       a.run();
       b.run();
   }
}
class MyThread extends Thread{
   private String name;
   MyThread(String name ){
       this.name = name;
   }
   @Override
   public void run() {
       for(int i =0;i<10;i++){
           System.out.println(name+"-------"+i);
       }
   }
}
<<<
Thread_a-------0
Thread_a-------1
Thread_a-------2
Thread_a-------3
Thread_a-------4
Thread_a-------5
Thread_a-------6
Thread_a-------7
Thread_a-------8
Thread_a-------9
thread_b-------0
thread_b-------1
thread_b-------2
thread_b-------3
thread_b-------4
thread_b-------5
thread_b-------6
thread_b-------7
thread_b-------8
thread_b-------9

调用run方法的话就是正常的调用，并没有使用任务的切换过程。

package lesson11;
public class test3 {
   public static void main(String [] args){
       MyThread a = new MyThread("Thread_a");
       MyThread b = new MyThread("thread_b");
       a.start();
       b.start();
       System.out.println("over");
   }
}
class MyThread extends Thread{
   private String name;
   MyThread(String name ){
       this.name = name;
   }
   @Override
   public void run() {
   for(int i =0;i<10;i++){
       System.out.println(name+"-------"+getName());//getname可以获取线程的名字
   }
}
}
<<<
over
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
Thread_a-------Thread-0
Thread_a-------Thread-0

两个子线程的运行不影响主进程的巡行运行

package lesson11;
public class test3 {
   public static void main(String [] args){
       MyThread a = new MyThread("Thread_a");
       MyThread b = new MyThread("thread_b");
       a.run();
       b.run();
       System.out.println("over");
   }
}
class MyThread extends Thread{
   private String name;
   MyThread(String name ){
       this.name = name;
   }
   @Override
   public void run() {
       for(int i =0;i<10;i++){
           System.out.println(name+"-------"+getName());
       }
   }
}
<<<
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
Thread_a-------Thread-0
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
thread_b-------Thread-1
over

主函数调用run方法应该只有一个线程在执行没什么调用getname还是能显示Thread-0

这个方法返回的是线程所属于的线程组，并不是正在执行的线程。

package lesson11;
public class test3 {
   public static void main(String [] args){
       MyThread a = new MyThread("Thread_a");
       MyThread b = new MyThread("thread_b");
       a.run();
       b.run();
       System.out.println("over");
   }
}
class MyThread extends Thread{
   private String name;
   MyThread(String name ){
       this.name = name;
   }
   @Override
   public void run() {
       for(int i =0;i<10;i++){
           System.out.println(name+"-------"+Thread.currentThread().getName());//现在正在执行的线程
       }
   }
}
<<<
Thread_a-------main
Thread_a-------main
Thread_a-------main
Thread_a-------main
Thread_a-------main
Thread_a-------main
Thread_a-------main
Thread_a-------main
Thread_a-------main
Thread_a-------main
thread_b-------main
thread_b-------main
thread_b-------main
thread_b-------main
thread_b-------main
thread_b-------main
thread_b-------main
thread_b-------main
thread_b-------main
thread_b-------main
over

package lesson11;
public class test3 {
   public static void main(String [] args){
       MyThread a = new MyThread("Thread_a");
       MyThread b = new MyThread("thread_b");
       a.start();
       b.start();
       System.out.println("over"+Thread.currentThread().getName());
   }
}
class MyThread extends Thread{
   private String name;
   MyThread(String name ){
       this.name = name;
   }
   @Override
   public void run() {
       for(int i =0;i<10;i++){
           System.out.println(name+"-------"+Thread.currentThread().getName());
       }
   }
}
<<<
overmain
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
Thread_a-------Thread-0
thread_b-------Thread-1
thread_b-------Thread-1