this super static abstract final

this super static abstract final 

this关键字
         作用：
                表示类中的属性
        调用本类的构造方法
        表示当前对象
          举例：
                 表示类中的属性：
    

class Person{
	      private name;//类中的属性name
		  public Person(String name){//方法的参数name
		  this.name=name//将参数name的值传给类中的属性name`
		  }
	}

调用本类的构造方法
假如一个类中有多个构造方法，则可以使用this关键字调用

	public Person(){
	      System.out.print("I'M A PERSON")
	}
	
	public Person(String name){
	    this();//调用上面的那个无参的构造方法
		this.name=name
	}
	attention!         this();要放在构造函数的第一行

表示当前对象

	public boolean compare(Person per){
      Person p1=this;
	  Person p2=per;
	  if(p1==p2){
	    return true;
	  }
	}

谁调用这个compare方法，this就表示谁。



 
 
super关键字
              作用：
                      从子类中调用父类的①构造方法②普通方法和③属性
举例：

package com.mjc.supers;
class Person{
	public String country="China";
	private String name;
	private int age;
	public Person(String name,int age){
		this.setName(name);
		this.setAge(age);
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getInfo(){
		return "name: "+this.getName()+" age: "+this.getAge();
	}
}


class Student extends Person{
	private String school;
	public Student(String name,int age,String school ){
		super(name,age);//①指定调用父类的构造方法
		this.setSchool(school);
	}


	public String getSchool() {
		return school;
	}


	public void setSchool(String school) {
		this.school = school;
	}
	public String getInfo(){
		return super.getInfo()+" School: "+this.getSchool()+//②调用父类的普通方法
				" country: "+super.country;//调用父类的属性
	}
}
public class SuperDemon1 {
  public static void main(String args[]){
	  Student stu =new Student("liwei",21, "shangli");
	  System.out.println(stu.getInfo());
  }
}

注意super（）也要放在构造方法的首行，所以不能和this（）一起使用
super的作用和this相识，区别在于：
                                  this是在本类中调用，super是在子类中调用父类
                                                  this有表示当前的用法，super没有
 
 


Static关键字
              作用：
          static声明属性则此属性称为全局属性（静态属性）
如果在一个对象中修改属性值，其他对象的该属性值也会跟着变
 
static声明方法称为类方法，可以由  类名.方法名（） 直接调用

而不需要又对象去调用

static 修饰class

比如有一个功能模块 class A{}
这个模块里，因为功能需要，需要一个更小的，功能单一的小模块。
并且这个模块是不需要实体化的，例如这个模块的功能是字符串加密机。
是那种，拿来就能用的，直接取返回值，所以定义为静态的。
因为是加密机，尽量不让其他模块访问这个功能，就可以这么定义为私有的。
可以向下面这样：
putlic calss A{
private static class A_a{
static String tat(String s){……}
}
}
类A里面有一个私有的静态类A_a,
内部静态类A_a里面有一个静态的方法tat。
比如这是个字符串加密算法。想吧"abc"加密，就这么用：String t = A_a.tat("abc");
字符串t就是加密过的“abc”了。当然这东西只能在A类里面使用。外面是访问不到的。

注意：当然这东西只能在A类里面使用。外面是访问不到的。

 
 
final关键字
  作用：
      使用final修饰的类不能有子类
 使用final声明的方法不能被子类复写
 使用final修饰的变量就变成了常量，常量是不能被修改的
   注意：
       在使用final声明变量时，要求全部的字母大写，如下，这点在开发中很重要
  public final String INFO=“LIWEI”;
  用public static final 声明的变量为全局常量如下
  public static final String INFO=“MJC”;
  
  
  
  

abstract关键字

    简介：抽象类像是一个模板，去规范将要派生的子类，抽象类不能去实例化对象，而是让他的子类去实例化
   使用规则：
        如果一个类中有抽象方法，那这个类必须是抽象类。
         抽象方法需要声明，不需要实现（例如public abstract print() 不要写方法的实体）
 抽象类必须被子类继承，如果其子类不是抽象类，要覆写父类的抽象方法
 
抽象类和接口的区别：


简单来说，
接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，


另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。


还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用.