Java中常见的关键字

class

  Java是面向对象的的语言，万物皆对象，类就以class来定义的。

public class Animals{}	//定义一个动物类
class Cat{}				//定义一个猫类

注意：在一个类中，可以定义多个类，但只能有一个public修饰符修饰的类。

public class Test{}
class Test1{}
class Test2{}

public

  public称为控制权限修饰符，还有private、default（默认）、protected。

  作用：授权该程序，使外部的程序能够访问。

  使用：类、成员变量、方法。

void class People{}			//用于类 defalut(默认)
public class Person{		//用于类
	private int age;		//用于成员变量
	String name;	
	
	public void setAge(int age){	//用于方法
		this.age = age;
	}
}

控制权限的大小： public > protected > default(默认) > private

	public	protected	default(默认)	private
同个类	可以	可以	可以	可以
子孙类	可以	可以	可以	不可以
同个包	可以	可以	不可以	不可以
其他包	可以	不可以	不可以	不可以

注意：类的存在是为了创建对象来使用相应的东西，而private修饰的类无法被外部访问，那么创建了对象，也毫无意义。同理，protect修饰的类能被子类、本包里的类使用，意义也不大。所以修饰类的只有public和default(默认)。

this

是什么？
  显然，本意是"这个"的意思，在Java中代表的是当前的对象。

怎么用?

1.用于成员变量：

public class People{
	String name;
	
	public void setName(String name){
		this.name = name;	//this.name 代表的是该对象的name属性
	}
}

2.用于构造方法里：

public class People{
	int age;
	
	public Test(){			//无参构造
		this(21);			//通过无参构造调用有参构造，要写在第一行。
	}
	public Test(int age){	//有参构造
		this.age = age;
	}	
}

注意：

  一、this只能在实例方法，不能在静态方法里。因为静态方法不需要对象就能调用静态方法。而实例方法需要对象才能调用，也就是this。
  二、this和super不能共存。

super

是什么？
  super是继承的象征，有继承说明有super。Java中所有的类都默认继承了Object类，也就是说每一个类都有super的存在。

怎么用？

1.用于访问父类的成员变量：super.成员变量;

public class Animal{
	String name = "猫";
}

class Cat extends Animal{
	String name;
	
	public Cat(){
		name = super.name;	//将父类Animal的name赋值给Cat的name
	}
}

2.用于调用父类的构造方法：super();

public class Animal{
	String name;
	public Animal(){
	}
	public Animal(String name){
		this.name = name;
	}
}

class Cat extends Animal{
	String name;
	
	public Cat(){
		super("猫");	//根据()里传的参数决定调用哪个父类的构造器
	}
}

3.用于调用父类的方法：super.方法名(参数);

public class Animal{
	public String getAnimalInfo(){
		return "这是动物类";
	}	
}

class Cat extends Animal{
	public void getCatInfo(){
		System.out.println(super.getAnimalInfo()+"中的猫类");		//调用父类的方法
	}
}

注意：
  一、构造方法里省略了super，因为所有的类都继承了Object类。

  二、在构造方法里，super默认在第一行，说明此处不能与this同时出现。

static

是什么？
  字面意思理解为静态的，什么也没有，方便程序的使用。可以在程序执行前做一些其他事。

怎么用？

1.用于内部类：

public class Animal{
	public static class Dog{	//定义一个静态内部类
	}
}

2.用于静态代码块：

public class Test{
	static{		//定义一个静态代码块
		System.out.println("static:" + "这是1");
	}
	
	public static void main(String[] args) {
        System.out.println("main:"   + "这是2");
    }
    
    static{		//定义多个代码块
        System.out.println("static:" + "这是3");
    }
}

运行结果如下：
static:这是1
static:这是3
main:这是2

结论：
  一、静态代码块先于main方法执行，并且无论静态代码块位置在哪，都比main方法先执行。

  二、代码至上而下执行，多个静态代码块遵循从上到下依次执行。
  三、在类加载时执行，只执行一次

3.用于静态方法：

public class Animal{

    public static void getAnimalInfo(){		//静态方法
        System.out.println("这是动物类");
    }
    public static String getAnimal(){		//有返回值的静态方法
        return "动物";
    }
    
    public static void main(String[] args) {
   		Animal animal = new Animal();
   		animal.getAnimalInfo();	//通过引用调用静态方法
   		//Animal.getAnimaInfo();
        getAnimalInfo();		//省略类名直接调用静态方法
        System.out.println(getAnimal());
    }
}

经过上面代码，我们发现静态方法可以用引用来调用，也可以直接使用方法名来调用。那么区别在哪？

结论：
  一、静态方法属于类级别的，不是对象级别的，所以通过类名来调用。
  二、在当前类中调用静态方法，类名可以省略。
  三、静态方法直接使用类名来调用，为了方便。但也可以通过对象的引用来调用静态方法，但没这个必要，因为要创建对象。

4.静态变量

是什么？
  静态变量又称为类变量，是使用static修饰的成员变量。

怎么用？

public class Animal{
	static int age;		//定义一个静态变量
}

静态变量和成员变量的区别：

	名称	使用方式	存储位置	生命周期
静态变量	类变量	类名.静态变量	方法区	该类加载完就存在、随着类的消失而消失
成员变量	实例变量	对象的引用.成员变量	堆内存	对象实例化完就存在、随着对象被回收而释放

final

是什么？
  final翻译为最终的，汉语里最终的通常是一个结局，说明故事结束了，结局明了。

怎么用？

1.用于类上：

//比如Java自带的String类
public final class String{
	......
}

2.用于变量上：

public class Person{
	/*
	final int ID_CARD;	报错，因为不会赋默认值
	解决:
	1.通过构造器赋值
	public Person{
		this.ID_CARD = 123456;
	}
	2.手动赋值*/
	final int ID_CARD = 123456;		//定义在成员变量
	
	public static void main(String[] args) {
		final int number = 200;		//定义在局部变量
	}
}

注意：
  一、static和final一起用在变量上称为常量，为了节省内存。
  二、常量也有命名规范，每个单词大写，每个单词之间用下划线。

3.用于方法上：

public class Animal{

	public final void name(){}		//定义在方法上
	public static final void getAnimal(){}
	
}

4.用于引用上：

public class People{
	 public static void main(String[] args) {
		final People people = new People();		//定义在引用上

		//people = new Object();	此时peopel的地址不会变，无法指向其他对象
	}
}

结论：

	类	方法	变量	引用
final	该类无法被继承	该方法无法被重写	成员变量需要手动赋值、局部变量只能赋一次值	地址不会变，无法指向其他对象

extends、implements

是什么？

  继承是Java很重要的机制，通过extends关键字来实现，但Java只支持单继承，只允许继承一个类。而implements就很好的解决了这个问题，它可以实现多个接口，并且能和extends一起使用，但implements也有它的缺点。

怎么用？

先来看extends：

public class Animal{
	String name = "动物";
	public void getAnimal(){
		System.out.println("这是动物的name:" + name);
	}
}

class Cat extends Animal{	//Cat继承一个Animal类
	public static void main(String[] args) {
	 Cat cat = new Cat();
     String a = cat.name;	//name是从父类继承过来的
     System.out.println(a);
     Cat.getAnimal();		//getAnimal()也是从父类继承过来的
	}
}

implements:

public class Animal{
    String name = "动物";
    public void getAnimal(){
        System.out.println("这是动物的name:" + name);
    }
}
class Cat extends Animal implements TestAnimal{	//接口和继承一起使用
    @Override
    public void getAnimalName() {
    	getAnimal();	//父类Animal继承得到的方法
        System.out.println("获取动物名字");
    }

}
interface TestAnimal{	//定义一个接口
    void getAnimalName();
}
class Test{
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.getAnimalName();
    }
}

结论：

	语法	混合使用	获取内容	注意
extends	class A extends B{}	class A extends B implements C,D{}，代表了A继承了B并且A实现了C、D接口	除了构造器和private修饰的，其他都能继承	继承了父类，父类的东西自己也有一份，可用可不用
implements	class A implements B{}	接口只能使用extends接口，但是可以继承多个接口	只能获取常量和抽象方法	实现接口，必须实现接口里的所有方法

throw、throws

是什么？
  对异常的处理有两种，分别是try-catch语句块和throws。throws是通过抛给上一级，让上一级来处理。假如我想抛出任意一个异常，可以使用throw。

怎么用？

先来看throws：

public class TestException {
    public void mathNumber() throws Exception{	//2.解决异常，往上一级抛，谁调用我谁就处理该异常。
        int a = 0;
        int b = 2;
        System.out.println(b%a);	//1.程序出异常了。
    }
}
class Test extends TestException {
    public static void main(String[] args) throws Exception {	//6.main方法也不愿意处理，只能交给JVM了，JVM得到异常后罢工，程序结束。
        Test test = new Test();
        test.otherMethod();		//5.在main方法里，otherMethod()抛了个异常过来，让main方法来处理。
        System.out.println("程序执行完了");
    }
    public void otherMethod() throws Exception {	//4.otherMethod()不愿意处理异常，继续往上抛异常。
        mathNumber();		//3.该方法里有一个异常，需要otherMethod()来处理。
    }
}

运行结果：

Exception in thread “main” java.lang.ArithmeticException: / by zero
at TestException .mathNumber(TestException .java:8)
at Test.otherMethod(Test.java:18)
at Test.main(Test.java:14)

再来看throw：

//自定义一个异常
public class TestException extends RuntimeException{	
    public Test3(){
    }
    public Test3(String s){
        super(s);
    }
}

class Test{
    public static void main(String[] args) {
        int a = 10;
        if(a == 10){	//根据条件来抛出异常
            //throw new TestException ("假如我是个异常");			//抛出自定义异常
            throw new ArrayIndexOutOfBoundsException("其实我也是个异常");	//抛出任意异常
        }
    }
}

注意：
  某行代码出了异常，使用throws方式来处理异常，该行下面的代码不会执行。

synchronized

是什么？
  为了解决线程同步问题而存在。

怎么用？

1.用于代码块

synchronized(任意对象){}

2.用于实例方法

public synchronized void method(){}

3.用于静态方法

public static synchronized void method(){}

简单的聊了下常见的关键字，详细的会在大章节里讲。