如歌的java学习~~~每天都有进步_如歌根据项目学习java-CSDN博客

本文链接：https://blog.csdn.net/qq_35776392/article/details/65033999

数组的创建及初始化(19)

public class 数组的创建及初始化 {
public static void main(String[] args) {
	int [] intarr=new int[1];
	String [] stringarr=new String [1] ;
	byte [] bytearr=new byte[1];
System.out.println("int类型的初始化："+intarr[0]);
System.out.println("String类型的初始化："+stringarr[0]);
System.out.println("byte类型的初始化："+bytearr[0]);

int [] arr=new int [5];
arr[0]=1;
arr[1]=2;
arr[2]=3;
arr[3]=4;
arr[4]=5;
for(int a=0;a<arr.length;a++){
	System.out.println(arr[a]);
}
int [] arr1={1,2,3,4,5,6,7,8,9};
for(int a=0;a<arr1.length;a++){
	System.out.print(arr1[a]);
}

}
}

如何使用数组(20)

public class 冒泡排序 {
	public static void main(String [] args){
		int a[] = {1,2,3,3,4,5,6,4,3,2,1,3,4,3,5,7,7,5};
		int temp=0;  
	    for(int i=0;i<a.length-1;i++){  
	        for(int j=0;j<a.length-1-i;j++){  
	        if(a[j]>a[j+1]){  
	            temp=a[j];  
	            a[j]=a[j+1];  
	            a[j+1]=temp;  
	        }  
	        }  
	    }  
	    for(int i=0;i<a.length;i++)  
	        System.out.println(a[i]);     
	}
}

多维数组(21)

多维数组就是数组嵌套数组

public class 二位数组初始化及遍历 {
public static void main(String[] args) {
	//二位数组的初始化
	int [][] a={
			{1,1,1,1},
			{2,2,2,2},
			{3,3,3,3},
	};
	//二位数组的遍历
	for(int b=0;b<a.length;b++){
		for(int c=0;c<a[b].length;c++)
		{
			System.out.print(a[b][c]);
		}
		System.out.println();
	}

}
}

类的一般形式(22)

变量修饰符:public、protected、private、和默认（frieddlly）

public 公共访问控制符指定该变量为公共的他可以被任何对象方法访问

private私有访问控制符指定变量只允许自己类的方法访问其他任何类（包括子类）中的方法都不能访问呢这个变量

protected 保护访问控制符指定此变量只允许被他自己的类或者同一个包中的其他类访问在子类中可以覆盖此方法

默认(无修饰符)在本类或者同一个包中有效

static 静态修饰符指定不需要实例一个对象就可以激活的方法

abstract 抽象修饰类指定该方法只声明方法头没有方法体抽象方法需要在子类中实现

方法与主方法(23)

方法：如果方法没有有返回值，必须写void

如果有返回值，定义的方法类型必须和返回值类型一致。

Java的主方法：public static void main(String args[])

public:表示最大的权限，所有的对象都可以使用

static:表示可以由类名直接调用，主方法是程序的入口，它的调用不必经过类的实例化，所以要有static关键字修饰

void:表示返回值为空，主方法是一切的起点，不能返回重来，所以没有返回值

main:main是系统内建的名称

args[]:字符串数组用于接收参数，参数之间用空格隔开

java 类名参数1 参数2 参数3编译和执行函数后3个参数便存在了args[]数组中，在主方法中可以调用，对于本身存在空格的参数，加上双引号，作为一个参数传递。

线程的基本知识(53)

线程和进程

线程：轻量级的进程

进程：执行中的程序

线程本身不能单独运行，必须放在一个进程中才能执行！

java 的线程模型

新建状态线程被创建之后就处于新建状态
就绪状态新建状态的线程调用start()方法进入就绪状态；阻塞状态的线程接触阻塞之后进入就绪状态
运行状态处于就绪状态的线程，获得cpu的资源，该线程就进入了运行状态。
阻塞状态一个正在运行的线程，因为一些原因让出了cpu的资源暂时中止而进入的状态。
终止状态正常中止；强制中止：stop，destory，system.exit ；异常中止：当线程执行过程中，产生了异常，线程会中止。

继承thread类创建线程(54)

package com.jdbc.connection;

public class 线程1 extends Thread{
public void run(){
	for(int a=1;a<100;a++){
		
		try {
			Thread.sleep(100);
			System.out.println("线程"+a);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
	public static void main(String[] args) throws InterruptedException {
		线程1 qq= new 线程1();
		qq.start();	
		for(int i=0;i<100;i++){
			Thread.sleep(100);
			System.out.println("主线程"+i);
		}
		//qq.run();			//单线程调用main方法
				//调用多线程，进入就绪状态，等待cpu分配资源
		System.out.println("线程执行完毕");
	}
	
}

实现Runnable接口创建线程(56)

public class 线程实现runable implements  Runnable {
	public void run() {
		for(int i=0;i<100;i++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("这是线程"+i);
		}
	}
	
	
	public static void main(String[] args) {
		线程实现runable a= new 线程实现runable();
		
		Thread thread=new Thread(a);
		thread.start();
		
		for(int i=0;i<100;i++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("这是主线程"+i);
			
	}
}
}

多线程应用(57)

public class 多线程应用1 implements  Runnable{
	public void run() {
		for(int a=0;a<100;a++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("*");
		}
	
	}
	
}

public class 多线程应用2 implements Runnable {
	public void run() {
		for(int a=0;a<100;a++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("#");
		}
	}

}

public class 多线程应用测试 {
public static void main(String[] args) {
	多线程应用1 d1=new 多线程应用1();
	多线程应用2 d2=new 多线程应用2();
	
	Thread t1=new Thread(d1);
	Thread t2=new Thread(d2);
      System.out.println("-----t1------"+t1.getPriority());
      System.out.println("------t2-----"+t1.getPriority());
      t1.setPriority(9);
      t2.setPriority(1);
      System.out.println("-----t1------"+t1.getPriority());
      System.out.println("------t2-----"+t2.getPriority());
        t1.start();
	 t2.start();
}
}

1.多个线程并发执行

java对于每个线程能保证的是每个线程都能被启动与停止，但是对于那个线程先执行，那个线程后执行是没有保证的。

2.线程优先级

java中优先级高的线程有更大的可能性获取CUP，但不是优先级高的总是先执行，也不是优先级低的总不执行。

线程的调度(58)

1休息方法sleep（毫秒数），sleep（毫秒数，纳秒数）

2暂停方法yield（） a.yield 是a释放后资源大家一起来抢

3挂起方法join（）

public class 线程的调度 {
public static void main(String[] args) throws InterruptedException {
	/*thread1 t1=new thread1();
	Thread tt=new Thread(t1);
		tt.start();	*/
	thread2 t2=new thread2();
	Thread ttt=new Thread(t2);
		ttt.start();
		for(int j=0;j<100;j++){
			System.out.print("#");
			if(j==5){
				thread1.join();	
			}
		}

}
static class thread1 implements Runnable{
	public void run() {
		for(int a=0;a<100;a++){
			System.out.println("我是第"+a+"个数");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}

	public static void join() {
		// TODO Auto-generated method stub
		
	}
}

static class thread2 implements Runnable{

	public void run() {
		for(int i=0;i<100;i++){
	System.out.print("*");
			}		
	}
	
}
}

线程同步问题的由来