Java重要关键字

权限关键字

private权限修饰 声明为 private的成员表示为类私有，用户无法在其他类的程序代码中直接存取。如果没有声明权限修饰的成员，只有在相同包的类程序代码中才可以直接存取，也就是“包范围权限”。如果不同包的类程序代码中，想要直接存取就会出现错误信息。如：

public class CashCard {
	private int balance;
	public CashCard(String number, int balance, int bonus) {
		this.balance=balance;
	}
复制代码

CashCard card1=new CashCard("A001", 1000, 0);
card1.balance+=100;//执行错误
复制代码

可以通过在private那个包里构建好方法，调用方法自定义更改：

	void save(int money) {//存钱调用
		if(money>0) {
			this.balance+=money;
			if(money>=1000) {
				this.bonus++;
			}
		}else {
			System.out.println("error");
		}
	}
	void charge(int money) {//取钱调用
		if(money<0) {
			if(money<this.balance) {
				this.balance-=money;
			}else {
			System.out.println("钱不够");
			}
		}else {
			System.out.println("error");
		}
	}
	int exchange(int bones) {//兑换红利
		if(bonus>0) {
			this.bonus-=bonus;
		}
		return this.bonus;
	}
	
	void output(){
		System.out.printf("%s%d%d",this.number,this.balance,this.bonus);
		
	}
复制代码

		int money=scan.nextInt();
		CashCard card1=new CashCard("A001", 1000, 0);
		CashCard card2=new CashCard("A002", 500, 0);
		CashCard card3=new CashCard("A003", 300, 4);
		
		card1.save(money);
		card2.charge(money);
		card3.exchange(money);
		card1.output();
复制代码

取值方法：

        //取值
	int getbalance() {
		return balance;
	}
复制代码

        card1.output();
		System.out.println(card1.getbalance());
复制代码

如果想在其他包的类程序代码中存取某包的类或对象成员，则该类或对象成员必须是公开成员，在Java中要使用 public加以声明。 public权限修饰 声明类为 public，这表示它是个公开类，可以在其他包的类中使用。可以在构造函数上声明pub11c，这表示其他包中的类可以直接调用这个构造函数。可以在方法上声明 public，这表示其他包的方法中可以直接调用这个方法。如果愿意，也可以在对数据成员上声明 public。包管理其实还有权限管理上的概念，没有定义任何权限关键字时，就是包权限。如果类上没有声明public权限关键字，类中的方法声明就算是 public，也等于是包权限了，因为类本身是包权限，其他包根本就无法使用类，更别说当中定义的方法。 protected权限修饰 被声明为protected的成员相同包中类可以直接存取，不同包中的类可以在继承后的子类中直接存取。

关键字	类内部	相同包类	不同包类
public	可存取	可存取	可存取
protected	可存取	可存取	子类可存取
无	可存取	可存取	不可存取
private	可存取	不可存取	不可存取

this关键字 除了被声明为 static的地方外，this关键字可以出现在类中任何地方，在对象建立后为“这个对象”的参考名称。在构造函数参数与对象数据成员同名时，可用this加以区别。在Java中，this（）代表了调用另一个构造函数，至于调用哪个构造函数，则视调用this（）时给的自变量类型与个数而定。

public Unboxing(int a) {
		if(a>0) {
			this.a=a;
		}
	}
	public Unboxing(int a,boolean b) {
//		if(a>0) {
//			this.a=a;
//		}  直接用this（a）执行
		this(a);
		if(b=false) {
			this.b=b;
		}
	}
复制代码

在上例中，this（a）会调用public Unboxing（int a）版本的构造函数，再执行if（b=false）之后的程序代码。注意this调用只能出现在第一行，构造函数不同于方法，构造函数与类名同名。 static 类成员 例如

class Ball{
    double radius;
	final double PI=3.14;
	}
	......
复制代码

如果建立多个ball对象，每个包对象都会有自己的radius和PI成员。圆周率其实是个固定的常数，不用每个对象各自拥有，可以在PI上声明 static，表示它属于类。（final关键字表示不可修改量，如果事先没有赋值，可以之后赋值final double;但是如果一直没有赋值会编译错误。如果class前使用final关键字，表示这个类为最后一个类，不可被继承。限定方法为final表示方法不可被重新定义）

class Ball{
    double radius;
	static final double PI=3.14;
	}
	......
复制代码

被声明为 static的成员，不会让个别对象拥有，而是属于类。如上定义后，如果建立多个Ball对象，每个Ba11对象只会各自拥有radius，PI属于Ba11类拥有 被声明为 static的成员，是将类名称作为名称空间。也就是说，可以这样取得圆周率:Systerm.out.println（Ball. PI）;也就是通过类名称与“.”运算符，就可以取得 static成员。 也可以声明方法为 static成员。例如:

 double radius;
		static final double PI=3.14;
		
	static double toRadians(double angdeg) {
		return angdeg*(Unboxing.PI/180);
		
	}
复制代码

被声明为 static的方法，也是将类名称作为名称空间，可以通过类名称与“.”运算符来调用static方法:System. out. println（Unboxing. toradians（100）)。另外， 虽然语法上这样也是可以通过参考名称存取 static成员，但非常不建议这样撰写:

    Ball ball= new Ball();
    System.out.printin(ball. PI);//极度不建议
    System.out.printin(ball. toRadians(100);//极度不建议
复制代码

Java程序设计领域，早就有许多良好命名习惯，没有遵守习惯并不是错，但会造成沟通与维护的麻烦。以类命名实例来说，首字母是大写，以static使用习惯来说，是通过类名称与“.”运算符来存取。在大家都遵守命名习惯的情况下，看到首字母大写就知道它是类。System.out、System.in中out、in也是System的static成员 与 import一样， import static语法是为了偷懒，但别偷懒过头，要注意名称冲突问题。有些名称冲突，编译程序可通过以下顺序来解析。
1、局部变量覆盖:选用方法中的同名变量、参数、方法名称。

2、成员覆盖:选用类中定义的同名数据成员、方法名称。

3、重载方法比较:使用 import static的各个静态成员，若有同名冲突，尝试通过重载判断。 如果编译程序无法判断，则会回报错误。

abstract抽象方法抽象类

如果某方法没有任何操作代码可以用abstract 标示该方法为抽象方法，不用撰写{}区块，直接；结束。而内含抽象方法的类class前也要标注abstract。如：

public abstract class Role(){
	.......
	public abstract void fight();
}
复制代码

类中若有方法没有操作，并且标示为 abstract，表示这个类定义不完整，定义不完整的类就不能用来生成实例，这就好比设计图不完整，不能用来生产成品一样。如上例所示，它表示这是一个定义不完整的抽象类（ Abstract Class）。如果试用抽象类创建实例，就会引发编译错误如：Role role =new Rple();不能实例化抽象类。子类如果继承抽象类，对于抽象方法有两做法，一种做法是继续标示该方法为 abstract（该子类因此也是个抽象类，必须在class前标示 abstract）；另一种做法就是操作抽象方法。如果两种做法都没有实施，就会引发编译错误。