JAVA----关键字用法

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 关键字修饰一个类时，该类不能被继承。

代码：

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
}
}