this引用表示当前对象本身，确切地说，this代表了当前对象的一个引用。对象的引用可以理解为对象的另一个名字，通过引用可以顺利地访问对象
this引用的3中用法
-
在实例方法中（注意不是static方法中）中作为本类当前对象将其引用作为自变量传递给其他方法。
如-
en=new Event(this); 在实例方法中将当前对象引用作为自变量传递给其他方法
-
services.add(this); 将当前对象添加到等待服务队列中
-
return this;返回当前对象
-
System.out.println(this);输出当前对象，其自动调用超类或Object的toString()方法。
父类Object的toString方法：getClass().getName() + “@” +
Integer.toHexString(hashCode()); 打印的是“类名@hascode
-
-
this.成员变量、this.成员方法（[参数列表])
这点大家想必都十分熟悉，不过多赘述 -
调用本类重载的构造方法
public Flower(String color){
this.color=color;
}
public Flower(String color,String name){
this(color); //注意这里this()应该为第一句，因为此前不存在任何对象。
//这个地方我也有点似懂非懂。
this.name=name;
}
static成员
Java类中的成员包括实例成员和类成员两种。类成员或静态成员用static修饰，而实例成员则不用static修饰。
某些成员希望独立于每个对象；或者说让每个对象都能使用；甚至没有创建对象时也能访问静态属性和静态方法。有时，人们不想父类的成员被子类覆盖，而只想让其被子类的成员隐藏。类变量类似于全局变量，类方法类似于全局方法
class Student{
public long idNum;
public String name;
private static long nextId=0; //注意这里类变量的使用
Student(){
idNum=nextId++;
}
public static void main(String []args){
System.out.println(new Student().idNum);
System.out.println(new Student().idNum);
}
}
类变量和实例变量：
类的所有实例共享类变量，每一个实例改变了类变量，都会永久的改变类变量，影响到其他的对象。
实例成员变量属于对象，必须通过对象引用；类成员变量属于类，一般通过类引用，用对象引用不规范，而且容易产生误解。
注：
类引用就是类名.类成员对象
实例引用就是实例对象.实例成员变量
类方法中不能使用this和super，因为其中没有可以操作的特定对象；不能创建内部类的实例；不能引用实例变量；不能直接调用实例方法，必须创建对象，用对象引用或调用.
就是说类方法只能直接访问类成员，如果要访问实例成员，需生成对象，用对象调用（就是在静态方法里new一个对象出来）；实例成员方法即可访问类成员，也可以访问实例成员。
类的继承
子类自动拥有父类除构造方法与私有成员以外的全部成员，包括成员变量和成员方法。
Java类只有单重继承，没有多重继承。如果一个子类具有一个直接父类，这种继承关系称为单重继承。有多个直接父类则称为多重继承。Java类只要单重继承，接口有多重继承。
子类继承父类的非私有成员变量，包括实例成员变量和类成员变量
子类继承父类除构造方法以外的成员方法，包括实例成员方法和类成员方法
子类不能继承父类中用final修饰的方法(这点会在后面讲final时候详述）
子类不能继承父类中被隐藏的成员变量或被覆盖的成员方法
特征
- 子类可以重定义父类成员，包括隐藏父类的成员变量、静态方法和覆盖父类的实例方法。
- 子类中可以访问父类中非私用的被隐藏和被覆盖的成员方法。（通过super.成员方法）
- 在子类的构造函数中，可通过super()方法将父类的变量初始化。
- 当父类为抽象类时，子类可覆盖父类中的抽象方法，并在子类中实现该方法。
Object类
Java中的类都是Object的子类
public class People{ }等价于public class People extends Object{ }
Java中的每个类都从Object类继承了成员方法，比较两个对象的方法equals()、转换为字符串的toString()方法。（Object的toString方法上面又说到的）。
上转型
OK，重点来了。学过C++的一定都知道上转型！
先看一个简单的demo
public class Demo {
public static void main(String[] args) {
Patterning patterning1=new Circle(2);
getInfo(patterning1);
Patterning patterning2=new Square(1,2);
System.out.println(patterning2.getName()+"'area is "+patterning2.getArea()+" and the perimeter is "+patterning2.getPerimeter());
((Square) patterning2).setLen(2,3);//这里因为父类中并没有setLen函数，所以下转型到Square。
//上转型对象调用不了子类新增加的成员或方法，这点很重呀！！
getInfo(patterning2);
}
static void getInfo(Patterning p){ //一般上转型的代码，都会有这样的函数，把父类作为参数传进去
System.out.println(p.getName()+"'area is "+p.getArea()+" and the perimeter is "+p.getPerimeter());
}
}
class Patterning{
private String name="Patterning";
public String getName(){
return this.name;
}
public double getArea(){
return 0
}
public double getPerimeter(){
return 0;
}
}
class Circle extends Patterning{
private double r;
private String name="Circle";
Circle(double r){
this.r=r;
}
public double getArea() {
return Math.PI*r*r;
}
public double getPerimeter() {
return 2*Math.PI*r;
}
public String getName(){
return this.name;
}
}
class Square extends Patterning{
private String name="Square";
private double length;
private double width;
Square(double length,double width){
setLen(length,width);
}
public public void setLen(double length,double width){
this.length=length;
this.width=width;
}
public double getArea() {
return length*width;
}
public double getPerimeter() {
return 2*(length+width);
}
public String getName(){
return this.name;
}
}
对象的上转型即声明一个父类类型的变量，但将子类的实例赋给它。或叫父类变量指向子类对象。
对于成员，如果父类有，子类没有则子类继承；如果父类没有，子类有，则属于子类增加的；如果父类子类都有，便属于隐藏或覆盖。其中对于成员变量或静态方法，属于隐藏；对于实例方法，属于覆盖。一般的，子类对象调用子类的成员，父类对象调用父类的成员。
但对于上转型的对象，则调用成员变量和静态方法时调用的是父类的，因此叫做隐藏成员变量和静态方法；调用实例方法时调用的是子类的，因此叫覆盖实例方法。
上转型对象调用不了子类新增加的成员或方法！！！
public class Test1{
public static void main(String []args){
A a=new A();
B b=new B();
A c=new B();
System.out.println("a.i="+a.i+","+"a.j="+a.j+",a.plus()="+a.plus());
System.out.println("b.i="+b.i+","+"b.j="+b.j+",b.plus()="+b.plus());
System.out.println("c.i="+c.i+","+"c.j="+c.j+",c.plus()="+c.plus());
}
}
class A{
int i=1,j=2;
int plus(){
return i+j;
}
}
class B extends A{
int i=10,k=20; //i与父类同名，隐藏了父类的i
int plus(){ //覆盖了父类的同名方法
return i+j+k;
}
}
a.i=1,a.j=2,a.plus()=3
b.i=10,b.j=2,b.plus()=32
c.i=1,c.j=2,.plus()=32 //注意c.plus()的j是B的j！！！
