this关键字，static关键字，package和import，访问控制，方法重写，super关键字

This关键字：

l  This它指向对象自己；

l  在类的定义方法中，使用this代表使用该方法的对象的引用；

l  当必须指出当前使用方法的对象是谁时要用this；

l  This还可以处理方法中成员变量和参数重名的情况；

l  This是一个变量，是当前对象的引用。

举一个例子：

class Leaf{

         inti = 0;

         Leaf(inti){this.i = i;}

         Leafincreament(){

                   i++;

                   returnthis;

         }

         voidprint(){

                   System.out.println("i="+ i);

         }

         publicstatic void main(String[] args){

                   Leafa = new Leaf(10);

                   a.increament().increament().print();

         }

}

/*

         结果：

         ---------------------

         i=12

         ---------------------

*/

在Leaf(int i){this.i =i;}中，可以认为this和i都一样，是个变量。因此在后面的Leaf类型的increament()方法中，this可以作为返回值，其实返回的是i的值。

Static关键字：

    凡是被标记为static的变量，都是静态变量，在类中是公有类型的，在定义时应该被初始化。静态成员可以通过对象引用或者用类名访问。

class Cat{

         privatestatic int sid;                 //定义一个静态变量

         privateString name;

         privateint id;

         Cat(Stringname){

                   this.name= name;

                   id= sid + 1;

         }

         publicvoid print(){System.out.println("My name is "+name+" and my NO.is "+id);}

         publicstatic void main(String[] args){

                   Cat.sid= 100;

                   Catmimi = new Cat("mimi");

                   mimi.print();

                   mimi.sid= 1000;

                   Catpipi = new Cat("pipi");

                   pipi.print();

         }

}

/*

         结果：

         ---------------------------

         Myname is mimi and my NO. is 101

         Myname is pipi and my NO. is 1001

         ---------------------------

*/

    Static关键字有几个特点：首先，被static标记的变量存放在内存的datasegment里面，只占有一块空间，被所有的对象所共享；任何对象都可以访问static类型的变量；即使没有对象，同样能访问。如上面的程序，Cat.sid = 100;和mimi.sid = 1000;

Package和import语句：

Package是把类打上包，import是把包导入类中。如果将一个类打包了，那么在使用该类的时候，要使用这个包的全名，即加上它所存在的路径。比如

cn.edu.aust.xbj.Catc = new cn.edu.aust.xbj.cat();

如果想省事的话，就在文件的开头用import cn.edu.aust.xbj.Cat,就搞定了。

类的继承：

Java中的继承用extends关键字，如果一个类继承了另一个类，那么它就拥有了该类的所有变量和方法。但是在Java中，只支持单继承。

//定义Person类，成员变量为名字和年龄，方法为设定姓名和年龄，返回姓名和年龄

class Person{

         privateString name;

         privateint age;

         publicvoid setName(String name){

                   this.name= name;

         }

         publicvoid setAge(int age){

                   this.age= age;

         }

         publicString getName(){

                   returnname;

         }

         publicint getAge(){

                   returnage;

         }

}

//定义一个Student类，从Person类中继承，添加属于自己的成员变量：学校，还有设定和返回学校的方法

class Student extends Person{

         privateString school;

         publicvoid setSchool(String school){this.school = school;}

         publicString getSchool(){return school;}

}

 

public class TestPerson{

         publicstatic void main(String[] args){

                   StudentTom = new Student();

                   Tom.setName("Tom");

                   Tom.setAge(23);

                   Tom.setSchool("AUST");

                   System.out.println(Tom.getName());

                   System.out.println(Tom.getAge());

                   System.out.println(Tom.getSchool());

         }

}

/*

         结果

         -------------------------

         Tom

         23

         AUST

         -------------------------

*/

从上面的程序可以看出，Person 是一个类，Student继承了Person这个类，Student也就继承了Person中的所有成员，它有了name和age，还能拥有自己的school。

访问控制：

访问控制主要是看几个关键字：public，private，protected和default。Public修饰的类可以在任何地方被访问。

class Person{

         privateint id = 10;

         privateString name = "John";

}

public class TestAccess{

         publicstatic void main(String[] args){

                   Persona = new Person();

                   System.out.println(a.id);

                   System.out.println(a.name);

         }

}

以上的程序在编译的时候，会出现这样的问题：

TestAccess.java:8:id 可以在 Person 中访问 private

               System.out.println(a.id);

                                    ^

TestAccess.java:9:name 可以在 Person 中访问 private

                System.out.println(a.name);

它的意思就是怎么能访问Person中的private类型的变量呢?说明private修饰的变量在别的类中是访问不了的。如果想访问，需要用到构造方法。

方法的重写：

子类从父类继承来了方法，如果觉得不是自己想要的，可以对这个方法进行重写。但是在重写的过程中，要注意：重写方法要和被重写的方法具有相同的类型、参数和返回类型，而且重写方法不能使用比被重写方法更高的访问权限，比如，原来的方法是public，那么重写的方法就不能是private。

class Person{

         privateString name;

         privateint age;

         publicvoid setName(String name){this.name = name;}

         publicvoid setAge(int age){this.age = age;}

         publicString getName(){return name;}

         publicint getAge(){return age;}

         publicString getInfo(){

                   return"My name is "+getName()+" and my age is "+getAge();

         }

}

 

class Student extends Person{

         privateString school;

         publicvoid setSchool(String school){this.school = school;}

         publicString getSchool(){return school;}

         publicString getInfo(){              //方法的重写

                   return"My name is "+getName()+",my age is "+getAge()+" andmy school is "+getSchool();

         }

}

/*

         结果：

         ----------------------

         Myname is John,my age is 23 and my school is AUST

         ----------------------

*/

 

public class TestOverWrite{

         publicstatic void main(String[] args){

                   Studenta = new Student();

                   a.setName("John");

                   a.setAge(23);

                   a.setSchool("AUST");

                   System.out.println(a.getInfo());

         }

}

在重写的时候一定要注意别写错了，比如看把方法名的大小写搞错了。那样的话编译不会出错的，但是得到的结果不是我们想要的，而且这个错误还很不好发现。比如我把方法的重写写成这样：

public StringGetInfo(){              //方法的重写

                   return "My name is"+getName()+",my age is "+getAge()+" and my school is"+getSchool();

         }

编译时没错，但是结果是这样的：

My nameis John and my age is 23

super关键字：

super关键字用于引用父类的方法。

class FatherClass{

         publicint value;

         publicvoid f(){

                   intvalue = 100;

                   System.out.println("Fathervalue:"+value);

         }

}

 

class ChildClass extends FatherClass{

         publicint value = 200;

         publicvoid f(){

                   super.f();

                   System.out.println("Childvalue:"+value);

                   System.out.println(super.value);

         }

}

 

public class TestInherit{

         publicstatic void main(String[] args){

                   ChildClasscc = new ChildClass();

                   cc.f();

         }

}

/*

         结果：

         -------------------------

         Fathervalue:100

         Childvalue:200

         0

         -------------------------

*/

    只要看到super，就要想到它引用的是基类的方法。