关键字总结

关键字总结

 
1.访问修饰符
public   共有的  公开性最大        
protected  受保护的  公开性其次
private   私有的    控制可见性最小

父类中的方法属性的修饰符是以下几种时，子类是否可以继承父类中的方法，属性。
情况是以下是三种时
同包同类           同包不同类     不同包不同类
public 可以          可以               可以
protected   可以          可以               不可以
private     可以          不可以             不可以
默认的      可以          可以               不可以

类：
和文件名完全相同的类就是主类，该类不可以被修饰为protected和private
类中的匿名内部类，内部类可以被修饰符为protected、private、默认的和public
接口中的匿名内部类、内部类、接口是可以被修饰符为默认的和public
和主类在一个文件中，和主类同级类的访问修饰符只能是默认的


2定义，实现，继承的关键字
class       定义类的                
interface  定义接口的             
        abstract   定义抽象类的
extends    继承类或抽象类的关键字
implements 实现接口的关键字
enum       定义枚举的关键字
        public class Student{}
public class UNStudent extends Student{}
public interface Shape{}
public class Drawing implements Shape{}
        public abstract class Write{}
        public class 类名 extends 类名或抽象类 implements 接口，接口，...{}


3.数据类型和值的关键字
byte        字节型
short       短整型
int         整型
long        长整型
double      双精度
float       单精度
boolean     布尔类型
char        字符型
null
true
false
this          表示当前的对象
super         表示调用父类的方法


this和super都可调用普通方法和构造方法
格式：
this.方法名      this(参数名，...，...)
super.方法名     super(参数名，...，...)
例
父类：
public class Student {
private String name;// 姓名属性
public Student(){
this("默认名字");
}
public Student(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setName(){
this.name=name;
}
public void study(){
System.out.println(name+"努力");
}
}
子类：
public class UNStudent extends Student{

public  UNStudent(){
//调用父类带一个字符串参数的构造方法
super("大学生");

}

public void study(){
super.study();
}

}

4.修饰方法和属性常量的

    1.static 静态的  
      static属性又称类属性，可以不创建类的对象而直接调用
      例public class ManagerTools {
  public static void main(String[] args){
//调用静态方法
ManagerTools.work();
ManagerTools mt=new ManagerTools();
mt.work();

}
public static void work(){
System.out.println("静态方法工作中");
}
public void workNotStatic(){
System.out.println("非静态方法工作中");
}

}
    当类中某一个对象的static属性改变后，这个类中所用对象的static属性值都会改变
    例
public  class Test {
    /**
* 主函数
*/
public static void main(String[] args) {
//实例化一个Student类的对象
Student stu = new Student("张三");

//实例化一个Student类的对象
Student stu2 = new Student("李四");
System.out.println("名字："+stu.getName());
System.out.println("名字："+stu2.getName());



}

}
如果Student类中定义姓名属性时为public String name；则上述运行结果为张三，李四
如为public static String name； 则上述运行结果为李四，李四


配合访问修饰符：
public  static 修饰的属性和方法在任何地方，只要有类名就可以直接以.的方式进行调用。
public class ManagerTools {
  public static void main(String[] args){
//调用静态方法
ManagerTools.work();
}
public static void work(){
System.out.println("静态方法工作中");
}


}

只要使用了static关键字修饰的属性，普通方法，类（匿名内部类和内部类），静态块在内存中都只有一份存在。
static {
//静态块
}
所有用static关键字修饰的都是会优先实例化在内存中。
     
   
    2.final 最终的
      a）final放在属性前面，属性就是常量，即这个属性值不能被改变
      public final String name；
      即name属性为常量，不能在被赋值
如
  b） 如果在方法前，当子类继承时则不能方法重写
   public final void study(){
       
System.out.println("学习中");
   }
   此方法只能被继承
  c） 如果一个类被final修饰那么该类不能被继承 

static和final关键可以一起来修饰匿名内部类，内部类，普通方法。
        static final Object ob= new Object(){};
定义常量
public static final 数据类型 常量名=值；
public static final String NAME="s";

     



5.条件和循环
if             if和else一般连用表判断 if(){}else{}
else
for                     for(int i=0;i<10;i++){}//使用循环创建对象
while                   while(//条件){}
do                      do{}while(//判定条件);do循环最少循环一次，结尾以分号结束
switch                  switch(){ case1:...;case2:...;}
case
        defalut                 用来switch语句中的默认分支
break                   用来提前跳出for，while和do循环或在switch语句中提前跳出case块
continue                用来跳转for，while和do循环的下一个迭代
return                  表示返回结果 ，用来跳出循环              


instanceof           用来判断当前的对象是否是某个类的实例。
synchronized         线程中使用，用来定义方法或其他的内容为同步
transient            IO中Object流中如果属性值不想写入到文件中就可以将属性定义为瞬时的。
assert               断言     程序执行到某一块代码时，执行的结构就是断言中指定的内容。

volatile             用来表示被多个线程异步修改的成员变量
strictfp             修饰类和方法，意思是FP-strict及strict float point，也就是说精确浮点的意思，符合IEEE-754规范
native              native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中

6.实例化对象的关键字
new
Student st = new Student();

7.关于包的
     package    指在java源文件中声明的类所驻留的java包
     import     引入包的关键字
    
   



8.处理异常的关键字
try 捕获异常的开始语句
catch 用来处理异常的关键字
finally 永远都执行的代码块
throw 用来创建一个新的异常
throws                     用来抛出一个异常


9.保留关键字
goto
const