JAVA总结（⼀）-----关键字分类及使⽤⼀.⽂章要点:
1.访问控制修饰符
修饰符英⽂名修饰符意译中⽂名
private私有的
public公有的
protected受保护的
2.类，⽅法、变量修饰符
修饰符英⽂名修饰符意译中⽂名
final强制禁⽌覆盖
abstract强制覆盖
static静态的
synchronized重量级锁-同步的
volatile轻量级锁
extends继承
super超
class类
new实例
interface声明接⼝
implements实现接⼝
strictfp精确浮点
transient不可序列化
native本地⽅法
3.程序控制关键字
关键字英⽂名关键字意译中⽂名
if条件关键字
else条件关键字
for循环关键字
while循环关键字
do循环关键字
switch选择关键字
case选择关键字
break结束循环关键字
continue结束本次循环关键字
return⽅法返回关键字
default选择关键字
instanceof判断某⼀对象是否属于某⼀类
4.包关键字
5.错误处理关键字
6.类型关键字
⼆.具体介绍（使⽤⽅法+代码实现）
1.访问控制修饰符
1）private--私有的
private关键字可声明⽅法，变量。不能标识类，其作⽤范围只能是当前类中，也就是说对于其他类，这些被标识的字段会被隐藏变成不可视。
class UesPrivate{
//声明⼀个私有的整型key变量
private int key;
//声明受保护的构造函数，其将造成不能实例化该类的对象
private void UsePrivate() {
}
}
//试图声明私有的接⼝结果出现"Illegal modifier for the interface Pint; only public & abstract are permitted"编译错误
private interface Pint{
}
//试图声明私有的类结果出现"Illegal modifier for the interface Pint; only public & abstract are permitted"编译错误
private class Example1{
}
2）public--公有的
public关键字可声明接⼝，类，⽅法，变量。被public关键字标识的字段，可以被其他类所调⽤，即使不在⽤⼀个java中，也可以被调⽤（但必须为与⽤⼀个java包）使⽤public关键字要注意⼀下⼏点
①.⼀个java⽂件只能有⼀个public关键字的顶级类
//尝试创建与⽂件名不同第⼆个带有public关键字的顶级类
//结果产⽣编译错误"The public type UsePublic must be defined in its own file"
public class UsePublic{
}
//带有public关键字的顶级类
public class keywordExample {
public static void main(String [] a) {
}
}
②.嵌套类可以使⽤public关键字
public class keywordExample {
//创建带有public关键字的成员类
public class UsePublic{
}
public static void main(String [] a) {
}
}
③.⼀个java⽂件不能有⼀个带有public关键字的接⼝
//尝试把带有public的接⼝创建在⽂件名顶级类的外部结果产⽣编译错误"The public type UsePublic must be defined in its own file"
public interface USP{
}
public class UseP{
//创建在顶级类内部的public接⼝
public interface UP{
}
}
④.带有public关键字的字段可以定义在类，接⼝的内部
class Example2{
//声明public的整型变量i
public int i;
//声明public构造函数
public void Example2() {
}
//声明public的类
public class Exp{
}
//声明public的接⼝
public interface Xp{
}
}
3）protected--受保护的
protected关键字可以声明⽅法，变量。不能声明接⼝，类。被protected声明的字段⾮其⼦类的类不能访问，即使在同⼀个java⽂件下，同⼀个包下。其字段只能被它的⼦类所访问.
class UseProtected{
//声明⼀个受保护的整型key变量
protected int key;
//声明受保护的构造函数，其将造成只能使⽤⼦类实例化该对象
protected void UsePrivate() {
}
}
class ChildProtected extends UseProtected{
public void ChileProtected() {
//⼦类使⽤⽗类受保护的key变量
this.key = super.key;
//实例化⽗类的对象
UseProtected up = new UseProtected();
}
}
public class keywordExample {
public static void main(String [] a) {
//不是UseProtected的⼦类实例化其对象产⽣编译错误“UsePrivate cannot be resolved to a type”
UsePrivate uu = new UsePrivate();
}
}
2.类，⽅法，变量修饰符
1)final--强制禁⽌覆盖
final关键字可以⽤于类，⽅法，变量作为他们的修饰符，不能修饰接⼝。final关键字的作⽤正如其翻译“最终的”，不可改变的。其意思也就是说，被修饰的字段不能被改变。
①.final修饰类时
当final作⽤于类时，即告诉这个类禁⽌继承。禁⽌继承的类主要是出于两⽅⾯考虑其⼀是性能，其⼆是安全。⽐如说
java.lang.Math和java.lang.String类都被fianl关键字所修饰。
//定义⼀个被final修饰的类UseFinal
public final class UseFinal{
public final void FinalExample() {
}
}
//尝试继承UseFinal类，产⽣编译错误“The type ChileFinal cannot subclass the final class keywordExample.UseFinal”
public class ChileFinal extends UseFinal{
}
②.final修饰⽅法时
当final修饰符作⽤于⽅法时，这个⽅法将不能被覆盖。对于在final修饰符作⽤的类内部的⽅法，⽆论定不定义都不将被覆盖。
//定义⼀个被final修饰的类UseFinal
public final class UseFinal{
//在final修饰的类内部的⽅法其也是不能被覆盖的
public final void FinalExample() {
}
}
//在没有final修饰符修饰类内部定义带有final修饰的⽅法。
//即使类被继承，在⼦类也不能覆盖这个⽅法
final void FinalExample2() {
}
③.final修饰变量时
当final修饰符作⽤变量时，这个变量将会被定义成常数。意思就是说，在其⽣命周期内这个变量的值将不会被改变。并且声明常数时只能在⽅法内部进⾏声明。final修饰变量时，不⽤管类，⽅法是否使⽤final修饰另外当被final修饰的变量在⽅法外部，类内部时必须对其赋值。
final void FinalExample2() {
static修饰的变量
//定义常数K，⼀般变量名采⽤⼤写与⼀般变量进⾏区分
final int K;
}
public final class UseFinal{
//在类内部，⽅法外部必须对该常数值进⾏赋值
//否则出现"The blank final field KEY may not have been initialized"编译错误
final int KEY = 2;
public final void UseKey() {
}
}
2)abstract--强制覆盖
abstract关键字修饰符只能修饰类，⽅法。不能修饰变量。abstarct和final恰好是两个意义相反的关键字。abstarct意思指被该关键字修饰的字段必须实现⼦类，或者覆盖其⽅法才能使⽤相关的字段
①.abstarct修饰类时
当abstarct修饰类时，此时想使⽤这个类的⽅法时，必须继承这个类才能使⽤，即该类不能被实例化。什么时候将使⽤abstarct修饰符修饰类？满⾜下列三个条件
1.存在若⼲⼦类
2.希望把所有不同的⼦类当做超类的实例处理
3.超类的对象本⾝没有实际意义
1.java.swt.Component是被abstarct修饰的类，其下⾯有许多的⼦类，都是⼀些关于控件的类⽐如说：滚动条类，对话框类，标签类。满⾜第⼀个条件
2.每个控件类都有许多的操作⽅法，但我们不需要知道是什么控件，就可以把这个控件加⼊到相应的容器中显⽰。满⾜第⼆个条件把所有的⼦类当做超类，加⼊到容器中显⽰。
3.对于Component类其没有具体的真实的对象，⽐如他的⼦类对话框类可以在容器上添加显⽰⼀个对话框，Component类没有具体这样的功能，因此这个超类本⾝是⽆意义的。
//⽗类没有具体的攻击招式
public abstract class AttackMonster{
public abstract void useArm();
public abstract void useLeg();
public void addAttack() {
}
}
//⼦类具有实际的攻击⽅法和怎么攻击的招式和对象
public class Man extends AttackMonster{
public void useArm() {
//使⽤⼿臂攻击..
}
public void useLeg() {
//使⽤腿攻击..
}
public void addAttack(AttackMonster a) {
//添加的相应的攻击招式不必知道谁添加..
//但是可以产⽣相应的效果
}
}
//同上⾯ Woman具有实际意义的攻击
public class Woman extends AttackMonster{
public void useArm() {
}
public void useLeg() {
}
}
public class Attack{
//创建⼀个攻击⽅法可以获得能够使⽤相应攻击的⼦类，传递的是⽗类的类型
public AttackMonster useAttack(AttackMonster a) {
a.useArm();
a.useLeg();
a.addAttack();
return a;
}
}
public static void main(String [] a) {
Attack ak = new Attack();
Man m = new Man();
//把相应谁使⽤的攻击招式使⽤
ak.useAttack(m);
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。