Java静态访问和抽象类

static：成员修饰符静态的意思修饰属性和方法
修饰的属性：静态变量或者类变量因为类变量是随着类的加载而加载。
类加载优先于对象类变量相对于实例变量
特点:
1.类变量被所有实例对象共享
2.访问方式类名.类变量直接访问。
修饰方法：静态方法/类方法（实例方法）
访问方式:类名.静态方法
通过类.方法名调用能够简单 static修饰属性或者方法会一直无法释放类变量导致内存空间被占用。
实例成员与静态成员互访：
静态成员可以访问静态不能访问非静态
非静态可以访问静态和非静态
静态方法里面不能存在对象实例。
静态方法不会出现this super 关键字
静态初始化语句：
static{
//执行语句
}
该语句用于给类初始化优先于main方法执行。只执行一次。

final：最终的意思，修饰符；
修饰类：代表最终类，不能被继承。
修饰方法：代表最终方法，不能被覆盖/重写
修饰变量：代表最终变量也就是常量值不能被改值。这种常量I可以在程序的任何位置被访问；
eg: public static final double MY_PI = 3.14；
空final变量的初始值必须在构造器中指定
public static int couse；
public Student（）{
couse = n；
}

抽象类：abstract
具体类：一种实体的抽象定义；
抽象类：一种类中的多种实体的抽象定义
抽象方法：没有方法体 public abstract void method（）；
具体类猫狗蛇鸟都有吃的动作吃的动作封装到抽象类父类中；
而吃什么封装到子类中，子类继承父类的抽象方法要重写原方法改写成具体方法。
特点：1.抽象方法一定在抽象类中
2.抽象类不能创建对象（不能实例化）
3.抽象类要有子类子类要重写抽象方法。
成员：抽象方法具体方法属性（类属性和实例属性）构造器
abstract class Pet{
private String name;
private int age;
private double weight;

public Pet（String name,int age,double weight）{
this.name = name;
this.age = age;
this.weight = weight;
}
//set/get
public double getWeight（）{
return weight;
}

public String toString（）{
return name +"..."+age+"...."+weight;
}

public abstract void eat（）;
}

class Bird extends Pet{
private String type;

public Bird（String name,int age,double weight,String type）{
super（name,age,weight）;
this.type = type;
}

public String toString（）{
return super.toString（）+"..."+type;
}

public void eat（）{
System.out.println（"eat....虫子"）;
}
}

class Cat extends Pet{
private String color;

public Cat（String name,int age,double weight,String color）{
super（name,age,weight）;
this.color = color;
}

public String toString（）{
return super.toString（）+"..."+color;
}

public void eat（）{
System.out.println（"eat....鱼"）;
}
}

class Dog extends Pet{
private int size;

public Dog（String name,int age,double weight,int size）{
super（name,age,weight）;
this.size = size;
}

public String toString（）{
return super.toString（）+"..."+ size;
}

public void eat（）{
System.out.println（"骨头"）;
}
}

class TestPet{
public static void main（String[] args）{
Cat c1 = new Cat（"小黑",2,8,"黑色"）;
Cat c2 = new Cat（"小白",3,3,"白色"）;

Dog d1 = new Dog（"小花",4,9,10）;
Dog d2 = new Dog（"小黄",4,20,20）;

Bird b1 = new Bird（"小绿",1,2,"黄鹂"）;
Bird b2 = new Bird（"小红",1,5,"八哥"）;

Pet[] pet = {c1,c2,d1,d2,b1,b2};
// sort1（pet）;
sort2（pet）;
print（pet）;

}

public static void print（Pet[] pet）{
for（Pet p : pet）
System.out.println（p）;
}

//冒泡排序体重
public static void sort1（Pet[] pet）{
for （int i = 0;i < pet.length-1 ;i++ ）{
for （int j = 0;j < pet.length -1-i ;j++ ）{
if （pet[j].getWeight（） < pet[j+1].getWeight（））{
Pet p1 = pet[j];
pet[j] = pet[j+1];
pet[j+1] = p1;
}
}
}
}
//选择排序
public static void sort2（Pet[] pet）{
for（int i = 0; i< pet.length; i++）{
int minIndex = i;
for（int j = i+1; j< pet.length;j++）{
if（pet[minIndex].getWeight（） > pet[j].getWeight（））
minIndex = j;
}
if（minIndex！=i）{
Pet temp = pet[minIndex];
pet[minIndex] = pet[i];
pet[i] = temp;
}
}
}
}本文永久更新链接地址：http://www.linuxidc.com/Linux/2016-10/136059.htm