关于java:我在上海乐字节学习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