关键字总结

（一）：访问修饰符
（1):private 表示私有的，不能被别的类所调用，只能在当前类下使用。例如：
public class Gjz {
private int x,y;//表示的是两个不同的整数。
}

public class WZQ {
private int x,y;//五子棋的横纵坐标
}
虽然都是用X，Y，定义的，但是两个x，y代表的是不同的意义。
(2):protected  表示受保护的，是同包下不同类可以访问，它处理的是继承的概念，通过protected我们可以将新成员添加到该现

有类中而不必碰该现有类。特别是在继承时我们只需要将上一个类中的方法调用出来即可。
例如：package cn.java.gjz;

public class Gjz {
protected int x=10, y=12;

public static void main(String args[]) {
Gjz show=new Gjz();
show.showUt();

}
public void showUt(){
System.out.println("打印"+x+"--------------"+y);
}

}//这是第一个类
打印出来的结果是：打印10--------------12
//这是第二个类
package cn.java.gjz;

public class GJZPro {
        protected void showUt(){
System.out.println("showUt");
}
}
打印出来的结果是：
打印10--------------12
同样的结果也就是我们成功调用了这个方法。

（3）：public    表示公有的，所有的类都可以访问。
在其他的的类中我们可以调用其方法。
例如：package cn.java.gjz;
//第一个类：
public class GJZPro {


        void showDraw(){
System.out.println("**********************");
}


}
//第二个类
package cn.java.gjz;

public class Gjz {
protected int x=10, y=12;

public static void main(String args[]) {
GJZPro  show=new GJZPro ();
show.showDraw();

}
// public void showUt(){
// System.out.println("打印"+x+"--------------"+y);
// }

}
输出结果是：**********************
这就是调用了GJZPro类中的showDraw方法，关键在于我们在调用其他的类的时候我们必须使用的是调用的那个类中的方法来初始化

对象。
（二）：基本数据类型：
int        整型 int x,y;表示的是想，x，y是整数。
short      短整型  而short的长度比int的短，还有long，表示的是长整型，长度最大。
char       字符型，表示的我们所定义的东西是属于自符类的。
float      单精度浮点型
double     双精度浮点型

boolean    布尔类型

byte       字节型


（三）定义类、接口、抽象类需要用的关键字：
class      定义类的关键字：．Class对象 Class对象包含了与类相关的信息。事实上，Class对象就是用来创建类的所有的“普通

”对象的。类是程序的一部分，每个类都有一个Class对象。换言之，每当编写并且编译了一个新类，就会产生一个Class对象。
public class Gjz {}
extends    用来继承的关键字：为什么要继承：在多次要用到相同的类时用继承可以省去重写方法的麻烦。

package cn.zhuangshuai.wzq.renren;

import javax.swing.SwingConstants;

public class WZQ extends javax.swing.JFrame {
private int count = 1;
private Win win;

public static void main(String[] args) {
WZQ wzq = new WZQ();
wzq.ShowUt();

}

public void ShowUt() {
this.setTitle("五子棋");
this.setSize(750, 650);
}
继承了JFrame类中的所有方法，获得了一个画板。
接口与接口的实现

interface  定义接口的关键字：为什么需要定义接口：在特定用途上，我们要求子类必须重写父类的方法，这就需要定义接口，
implements  实现接口的关键字。
package cn.java.lesson23;

public interface NJList {
public void add(String s);

public void delete(String str1, int index);

public String get(int index);

public int size();

}
package cn.java.lesson23;

public  class NJListTest implements  NJList {

private String [] scrA=new String [0];

/**
* 重写接口的方法
*/
public void add(String s) {
String[] scrB=new String [scrA.length+1];
scrB[scrB.length-1]=s;
//将元数组的东西放到新数组中
for (int t=0;t<scrA.length;t++){
scrB[t]=scrA[t];
}
//指向新数组
scrA=scrB;
}
        public void add(int index,String s) {
}
        public String get(int index) {

return scrA[index];
}
        public int size() {

return scrA.length;
}
        @Override
public void delete(String str1 ,int index) {
        }
}
//接口的实现使用implements 关键字，与类的extends不同的。实现类中，必须重写接口的方法！一个类可以继承多个接口。

abstract    定义抽象类和抽象方法的关键字（没用过以后用的时候在加上）。
static      静态的（方法、属性）
static中可以直接调用static方法，我们通常称为类方法，因为不需要对象即可创建。
static 方法
package cn.java.gjz;

public class ManagerTools {
public static void main(String args[]){
//调用静态方法
ManagerTools.work();

}
    public static void work(){
    System.out.println("静态局部方法调用中");
    }
}
static 属性又称之为类属性，可以类的某一个对象的static 属性被改变后，这个类所有对象的static属性值都将会改变。
例子：
package cn.java.gjz;

public class ManagerTools {

private static int count=1;
public static void main(String args[]){
ManagerTools mt=new ManagerTools();
mt.workNo();
//调用静态方法
ManagerTools.work();
ManagerTools.count=10;
//创建5个anagerTools 的对象
for(int i=0;i<5;i++){
ManagerTools m=new ManagerTools();
m.count=i;
System.out.println("count属性是"+mt.count);
}

}
public void workNo(){
System.out.println("非静态局部方法调用中");
}
    public static void work(){
    System.out.println("静态局部方法调用中");
    }
}
// static属性可以直接在任何方法里调用，但在static方法中，则只能调用static属性，非static属性，就必须通过创建对象调用

。
final     意为最终的，放在属性前面，属性的值就是常量，即这个属性的值是不能改变的，  修饰方法的时候不能进行重写。修

饰常量的时候不能改变常量的，修饰变量的时候不能改变变量的值，修饰类的时候表示该类不可以被继承。将变量或方法声明为

final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。

被声明为final的方法也同样只能使用，不能重载。
package     定义包的关键字。就相当于一个文件夹，多级之间用 "."隔开
import      引入包的关键字。引入时，可以在类前import java.awt.Color;。也可以在调用类时引入，cn.net.java.po.Student

st=new cn.net.java.po.Student();
条件和循环
if  else 一般在一起使用，
                                if (((x1 - Config.X) / Config.SIZE) % Config.SIZE < (Config.CHESS / 2)) {
j = (x1 - Config.X) / Config.SIZE;
System.out.println("+++++++++++++++++++++++++");
} else {
j = ((x1 - Config.X) / Config.SIZE) + 1;
System.out.println("**************");
}
if (((y1 - Config.Y) / Config.SIZE) % Config.SIZE < (Config.CHESS / 2)) {
i = (y1 - Config.Y) / Config.SIZE;
System.out.println("======================");
} else {
i = ((y1 - Config.Y) / Config.SIZE )+ 1;
System.out.println("----------------------");
}
                            
switch,case ,default;

switch(表达式)
{
  case 常量表达式:语句1;
  case 常量表达式:语句2;
  case 常量表达式:语句3;
  case 常量表达式:语句4;
  case 常量表达式:语句5;
  case 常量表达式:语句6;
  default           :语句m;
}
for(表达式1;表达式2;表达式;3)
    语句;
说明："表达式1"的作用是初始化循环控制变量；"表达式2"的作用是判断循环终止的条件，其一般关系表达式或逻辑表达式，也可

以是数值表达式或者字符表达式；表达式3的作用是改变控制变量的值。
while
do

break   如果循环中遇到了break,会结束当前循环，执行循环后边的语句
continue  退出本次循环
new  创建对象的关键字


this  表示当前的对象，意思是“我的”，具体到那个人。另一个用途是：就是可以在构造器中调用自己的另外构造器。
private int[][] data;

/**
* 定义一个带参数的构造器
*/
public Win(int[][] data) {
this.data = data;

}


null   一般用于对象和字符串的默认值

super   表示调用父类的方法  super 与this相比较，super 指的是当前类的父类对象。用super 可以重写父类的方法。在重绘时

重写父类的paint方法。



void  返回类型，表示不需要返回值。

return  表示返回一个结果

true/false  是boolean类型的值真/假