关键字的使用及注意:this static abstract final

this:

　　1..修饰属性,方法,构造器

　　2..我们在构造器或方法中,使用 this.属性 或 this.方法 的方式,显示调用的当前对象(或当前正在创建的对象)的属性或方法.只是大部分情况下我们选择省略this.

　　如果方法或构造器中传入的形参与属性同名,此时,我们必须使用显式的使用  this.变量   表示调用的是当前类中的属性,而非形参

　　3..this修饰构造器:格式在类的构造器当中可以通过"this(形参列表)"的方式显式调用当前类中指定的其它构造器

　　　this(形参列表) 必须声明在首行(第一行)

　　　在一个构造器当中只能声明最多一个this(形参列表)的结构

　　　如果一个类中有n个构造器,最多有n-1个构造器中使用了this(形参列表)

class Person{
		private String name;
		private int age;
　　　　　　　　　　public Person() {
            　　//创建Person类,就要如下初始化
            　　　　　　System.out.println("Person()....");
       　　　　 }
        
        　　　　　public Person(String name,int age) {
           　　　　 this.age=age;
           　　　　 this.name=name;
       　　　　 }
        
       　　　　　　 public Person(String n) {
           　　　　 //this写在第一排必须,否则报错
            　　　　　　this();
            　　　　　　name=n;
           　　　　 //this();
            
            　　}		

		public String getName() {
			return name;
		}
　　　　　　　　　//方法中的tring name 与Person类中的name同名
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		@Override
		public String toString() {
			return "Person [name=" + name + ", age=" + age + "]";
		}
		
		
		
}

 static:静态关键字,可以修饰属性,方法

　　注意:在类中修饰属性分为

　　　　1.实例变量:不用static修饰 ,每个都有一份  存储在堆空间

　　　　 2.静态变量:被static修饰,被大家共用,只有一份,存储在方法区的静态域

　　　　3.静态变量先于实例变量性创建

　　　　　实例变量随着对象的创建而加载,每个对象都有一份. 静态变量随着类的加载而加载,内存中只有一份

　　　　4. 静态方法原理同上

final:最终的,修饰方法属性,变量

　　1.用来修饰类,表明此类不能申明子类,比如String ,StringBuffer,StringBuilder

　　2.修饰方法,表明此方法不能被重写,比如Object类中的getClass():获取创建当前对象所属的类

　　3.修饰变量,表明该变量变成了常量,一旦赋值,就不可更改

1. 显是赋值: final int num=1;
   
2. 构造器赋值: 
3. 代码块赋值:  
4. static final 修饰同一个变量,表示此时他是全局常量　　

abstract:抽象的,修饰类,方法

1. 抽象方法没有方法体,

    public abstract goStudy();
   

    

2. 抽象类:不能实例化,但可以有自己的构造方法,目的是为了子类实例化的时候使用     　
3. 抽象方法在的类一定是抽象类,抽象类不一定有抽象方法
4. 子类继承抽象类后,如果子类重写所有的抽象方法,此子类就可以实例化,因为此时他不再是抽象类

         5. 子类继承抽象类后,如果子类没有重写所有的抽象方法,此时此子类依然是抽象类

abstract 不能有哪几个关键字使用:private final static

　　abstract 不能修饰私有方法,因为私有方法不能重写

　　abstract不能与final方法最终方法使用,因为fianl不可修改

　　abstract不能与static使用,因为静态方法不能重写

值得一提的是:   接口是抽象方法和常量的集合,在jdk7之前只能定义抽象方法和全局变量

1. 故接口内一般是 public static final修饰常量
2. 所有的抽象方法都是由public abstract 修饰的
3. 接口中没有构造器
4. 接口采用多继承机制
5. 接口可以看做关于具体问题定义的一套规范,且是可以多继承的

类和类的关系:继承(extends)

类和接口的关系:当类实现了接口后,要重写接口的抽象方法,进而可以实例化此实现类

　　　　　　　　当此类并没有重写所有的抽象方法,此时该实现类是抽象类,,使用abstract修饰,不能实例化

　　　　　　　　类可以实现多个接口

接口和接口的关系:接口之间是继承关系,是可以多继承的

如何创建接口的匿名实现类对象:

如何创建抽象类的实例方法;同如何创建接口的匿名实现类对象:

//定义一个接口
interface Usb{
　　　　start();
       stop();

}
//定义Usb的实现类1
class Printer implements Usb{
@override

public void start(){
System.out.println("打印机开始工作")
}

@override

public void stop(){System.out.println("打印机结束工作")}
}

//定义Usb的实现类2
class Flash implements Usb{
@override

public void start(){
System.out.println("U盘开始工作")
}

@override

public void stop(){System.out.println("U盘结束工作")}
}

class Computer{
public void transferData(Usb usb){
　　usb.start();
System.out.println("具体传输细节")
　　usb.stop();
}
}
//创建一个测试类
public class UsbTest{
　　public static void main(String[] args){
    　　Computer computer=new Computer();
　　　　//构建一个实现类对象
　　　　Printer printer =new Printer();
　　　　//相当于多态化 Usb usb =new Printer();  接口也可与实现多态性

　　　　computer.transferData(printer);

　　　　//创建接口的实现类Flash的匿名对象
　     computer.transferData(new Flash());

　　　　//创建一个接口的匿名对象
　　　　Usb u=new Usb(){
　　　　　　public void start(){}

　　　　　　public void stop(){}
　　　　};
　　　　computer.transferData(u);
　　//创建接口的匿名实现类的匿名对象

　　computer.transferData(new Usb()){
　　　　@override
　　　　public void start(){
　　　　System.out.println("电子书开始工作")
　　}
　　　　@override
　　public void stop(){
　　　　System.out.println("电子书结束工作")}
　　}
}
　　}
}