JAVA----关键字用法

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u013514722/article/details/49472269

this

使用注意：

1.代表所属函数的调用者对象。
2.如果存在同名的成员变量和局部变量时，在方法内部默认是访问局部变量（java编译器采用“就近原则”），但可以用this访问成员变量。
3.在一个构造函数中可以访问另一个构造函数，但是调用语句必须在该构造函数的第一个语句，另外这两个函数之间不能互相调用。
4.如果在一个方法中访问一个变量时，该变量只有成员变量时，java编译器会在该变量前加this。

代码：

class People
{
    int id;
    String name;
    int age;

    public People(int id,String name, int age)
    {
        this(age);
        this.id = id;
        this.name = name;
    }

     public People(int age)
    {
        this.age = age;
    }

    public void compara(People p1){
          if(this.age > p1.age)
              System.out.println(this.name + " big");
          else if(this.age < p1.age)
               System.out.println(p1.name + " big");
          else 
               System.out.println( "equals");
    }       
}



class Demo1 
{
    public static void main(String[] args) 
    {
         People a = new People(11,"Tom",48);
         People b = new People(12,"Marry",30);
         a.compara(b);
    }
}

static

static修饰成员变量：

访问方式：

   对象.属性名  或   类名.属性名（（比较常用））
   对象.函数名（）  或   类名.函数名（）（（比较常用））

使用注意：

 1.static 修饰成员变量时，该成员变量的数据属于共享数据。
 2.非静态成员变量只能用对象访问。
 3.静态函数能直接访问静态的成员，不能直接访问非静态成员，但如果静态函数中存在对象，则可以访问非静态成员。
 4.静态函数不能含有this和super关键词。
 5.非静态函数既能调用静态成也能调用非静态成员。
    **静态成员变量的数据优先于对象存在**。

 class ArrayTool
 {
     public static String  ToString(int[] arr)
     {
         String aa="";
        for(int i=0; i<arr.length; i++)
         {
            if(i==0)  aa+="["+arr[i];
            else if(i==arr.length-1)
                 aa+= arr[i] +"]";
            else 
                aa +=" "+ arr[i] + " ";
         }
         return aa;
     }

     public static void Sort(int[] arr)
     {
         int len=arr.length;
         for(int i=0; i<len; i++)
         {
             for(int j= i+1; j<len-1; j++)
             {
                 if(arr[i]>arr[j])
                 {
                     int temp;
                     temp= arr[i];
                     arr[i]= arr[j];
                     arr[j]=temp;
                 }
             }
         }
     }
 }

 class Demo2
 {
     public static void main(String[] args)
     {
        int[] arr = {1, 6, 9, 3, 5};
        ArrayTool.Sort(arr);
        System.out.println("Array" +  ArrayTool.ToString(arr)) ;
     }
 }

super

定义：

  代表父类空间的引用；

作用：

　１.子父类存在同名的成员时，在子类中默认是访问子类的成员，但可以通过super访问父类成员。
　2. 创建子类对象时，默认会调用父类无参的构造方法，可以用super指向父类的构造方法。

注意事项：

　１. 如果在子类的构造方法上没有指定调用父类的构造方法时，java编译器会在子类的构造方法上加上super。
　2. super关键字调用父类的构造函数时，该语句必须是子类构造函数的第一个语句。
　3. super 和 this 不能出现在同一个构造函数中。

final

作用：

final 关键字修饰一个基本类型变量时，该变量不能重新赋值，第一次的值为最终的。
fianl 关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
final 关键字修饰一个函数时，该函数不能被重写。
fianl 关键字修饰一个类时，该类不能被继承。

常量的修饰符一般为： public static final
常量一般全部用大写字母表示，单词之间用下划线隔开

代码：

class Circle 
{
    double r;
    final double pi = 4.0;
    public Circle(double r)
    {
        this.r = r;
    }
    public void getArea()
    {
        System.out.println("圆形的面积" + r*r*pi);
    }
}

class  Demo1  
{

    public static void main(String[] args) 
    {
        Circle c = new Circle(4.0);
        c = new Circle(5.0);
          c.getArea();
          //test(c);
    }

}

abstract

使用注意：

1.如果一个函数没有方法体，该函数必须用abstract修饰。
2.如果一个类有抽象函数，那么该类必须用abstract修饰。
3.如果一个非抽象的类继承了抽象的类，那么必须把抽象的方法全部实现。
4.抽象类不能创建对象。
5.抽象类可以存在非抽象方法和构造函数。
6.abstract不能与final ，static ， private 一起修饰一个方法。

代码：

//用抽象类求矩形，圆形的面积和周长
abstract class MyShape
{

    public abstract void getArea();

    public abstract void getLength();
}

class Rect extends MyShape
{
    double x,y;
    public Rect(double x,double y)
    {
        this.x = x ;
        this.y = y ;

    }
    public void getArea()
    {
         System.out.println("Rect " + x*y);
    }
    public void getLength()
    {
         System.out.println("Rect " + 2*(x+y));
    }
}

class Circle extends MyShape
{
    double r;
    public static final double PI = 3.14;
    public Circle(double r)
    {
        this.r = r;
    }
    public void  getArea()
    {
        System.out.println("Circle " + r*r*PI);
    }
    public void getLength()
    {
        System.out.println("Circle " + 2*r*PI);

    }

}


class Demo3
{
    public static void main(String[] args)
    {
        Circle ss = new Circle(4.0);
        ss.getArea();
        ss.getLength();
        Rect aa = new Rect(2,4);
        aa.getArea();
        aa.getLength();

    }
}

instanceof

定义：

  判断一个对象是否属于指定的类型

使用格式：

 对象  instanceof 类别

使用前提：

 判断的对象于指定的类型必须要存在继承或实现的关系

代码：

class Animal
 {
     String name;

     public Animal(String name)
     {
         this.name = name;
     }
 }

 class Dog extends Animal
 {
     public Dog(String  name)
     {
         super(name);
     }
     public void bite()
     {
         System.out.println(name + "咬人");
     }
 }

 class Mouse extends Animal
 {
     public Mouse(String name)
     {
         super(name);
     }
     public void dig()
     {
            System.out.println(name + "挖洞");
     }
 }

 class Demo2
 {
     public static void main(String[] args)
     {
         Dog ss = new Dog("dddddd"); 
         System.out.println("狗是狗类吗"+ (ss instanceof Dog));  //true
         Animal dd = new Animal("ffff");
         System.out.println("动物是狗类吗"+ (dd instanceof Dog)); //false 
     }
 }