Java中所有的关键字及用法

public void test(){

int a=10;
int b=5;

if(a>b){
sout（"a大于b");
}
elseif（b>a）{
sout（"b大于a"）;
}
else{
sout（"a和b相等"）;
}



}

String name="lixiaobin"；
switch（name）{

case "lixiaobin"：
sout（"lixiaobin"）；
break；

case "lixiaobin"：
sout（"zhangsan"）；
break；

case "lixiaobin"：
sout（"lisi"）；
break；
default:
sout("无效")
}

public void test（）{

int i=1；
whlie（true）

sout（“学习java”）；
i++;
if（i=5）
{

break;  
//i=5的时候跳出循环
}
}

public class Main {
    public static void main(String[] args) {
        int n=5,j=12;
        while(n<=j){
            System.out.print(n+"\t");
            n++;
            continue;
        }
        System.out.println("n="+n);
    }
}

语法结构：

do{
循环结构

}while(判断条件);

先执行do循环结构里面的代码，然后判断

while里面的条件是否符合，直到不成立为止，

所以do……while至少会被执行一次。

public void test（）{

int[] integers = {1， 2， 3， 4};
for (int j = 0; j<integers.length; j++){

int i = integers[j];

System.out.println(i);

}

}

public void test（）{

int[]numbers={1，2，3，4，5，6，7}

for（int num：numbers）{

    sout（num）
} 
}

Person p1=new Person();//一旦Person类抽象了就不可以实例化了。

abstract class Person{
    
}

    public class MyObject {
    	//非静态变量
    	private String str1 ="property";
    	//静态变量
    	private static String str2 ="staticProperty";
    	
    	public MyObject() {
    		
    	}
    	//非静态方法
    	public void print1() {
    		System.out.println(str1);
    		System.out.println(str2);
    		print2();
    	}
    	
    	//静态方法
    	public static  void print2() {
    		//这一句报错，报错信息是Cannot make a static reference to the non-static field str1
    		System.out.println(str1);
    		System.out.println(str2);
    		/*
    		 * 调用非静态的方法会报错，
    		 * Cannot make a static reference to the non-static method print1() from the type MyObject
    		 */
    		print1();
    	}
    }

public class A {
	
	private String nameA="A";
	
	public void getName() {
		System.out.println("父类"+nameA);
	}
	public static void main(String[] args) {
	}
	
}
 
 
public class B extends A{
	private String nameB="B";
	
	@Override
	public void getName() {
		System.out.println("子类"+nameB);
		super.getName();
	}
	
	public static void main(String[] args) {
		B b=new B();
		b.getName();
	
	}
}

public class A {
	
	 String nameA="A";
 
}
 
public class B extends A{
	 String nameA="B";
	
	
	public void getName() {
		System.out.println("子类"+nameA);
		System.out.println("父类"+super.nameA);
	}
	
	public static void main(String[] args) {
		B b=new B();
		b.getName();
	
	}
}

public class Student{
    String name;
    private void SetName(String name){
        this.name = name;
    }
}

public class ThisTest {
    String name;

   private void setName(String name) {
        this.name = name;
        System.out.println("setName: " + this.name);
    }


    private void thisTest(String name) {
        this.setName(name);
        System.out.println("thisTest: " + this.name);
    }

    public static void main(String[] args) {
        ThisTest tt = new ThisTest();

        tt.setName("Yida");
        tt.thisTest("Jenny");

    }
}

public class Student { //定义一个类，类的名字为student。 
    public Student() { //定义一个方法，名字与类相同故为构造方法
        this(“Hello!”);
    }
    public Student(String name) { //定义一个带形式参数的构造方法
    }
}

public class TestReturn { 
    public static void main(String args[]) { 
       TestReturn t = new TestReturn(); 
        t.test1(); 
        System.out.println(t.test2()); 
    } 
 
 
    /** 
     * 无返回值类型的return语句测试 
     */ 
    public void test1() { 
        System.out.println("---------无返回值类型的return语句测试--------"); 
        for (int i = 1; ; i++) { 
            if (i == 4) return; 
            System.out.println("i = " + i); 
        } 
        //System.out.println("hello,this world");此句不能执行，不可达代码
    } 
 
 
    /** 
     * 有返回值类型的return语句测试 
     * @return String 
     */ 
    public String test2(){ 
        System.out.println("---------有返回值类型的return语句测试--------"); 
        return "返回一个字符串"; 
    } 
}

public class AccountingSync implements Runnable{
    //共享资源(临界资源)
    static int i=0;

    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        AccountingSync instance=new AccountingSync();
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
    /**
     * 输出结果:
     * 2000000
     */
}

public class AccountingSyncClass implements Runnable{
    static int i=0;

    /**
     * 作用于静态方法,锁是当前class对象,也就是
     * AccountingSyncClass类对应的class对象
     */
    public static synchronized void increase(){
        i++;
    }

    /**
     * 非静态,访问时锁不一样不会发生互斥
     */
    public synchronized void increase4Obj(){
        i++;
    }

    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1=new Thread(new AccountingSyncClass());
        //new心事了
        Thread t2=new Thread(new AccountingSyncClass());
        //启动线程
        t1.start();t2.start();

        t1.join();t2.join();
        System.out.println(i);
    }
}

public class AccountingSync implements Runnable{
    static AccountingSync instance=new AccountingSync();
    static int i=0;
    @Override
    public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized(instance){
            for(int j=0;j<1000000;j++){
                    i++;
              }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}