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

内容版权声明:除非注明,否则皆为本站原创文章。

转载注明出处:https://www.heiqu.com/ee580354a8060891f5151ee7c2db62ea.html