JAVA 2022.7.14课程总结

一、  向上转型
        //父类的指针可以指向子类的对象
        //子类的对象可以贴上父类的标签
        //只能调用指针类型中定义的方法
        Truck bt2=new BigTruck("白色的");
        bt2.transport();
        Truck st2=new SmallTruck("黑色的");
        st2.transport();

1.例题：    

        //定义一个卡车类,两个子类,大卡车,小卡车,卡车类中有个运货的方法,大小卡车分别重写该方法
    //再定义一个货运站类,一个属性interval=50,在定义一个调度,根据一个货品重量,返回一个卡车
    //货运站,发货的方法,接受一个货品重量,通过调度方法获取卡车,调用卡车的运货的方法

public class Easy {
	public static void main(String[] args) {
		Easy e=new Easy();
		e.start();
	}
	
	public void start() {
		for(int i=0;i<20;i++) {
			double weight=Math.random()*80+20;
			Truck t=getTruck(weight);
			t.transport();
		}
	}
	double interval=50;
	/**
	 * 根据货重调度卡车(小卡车/大卡车)
	 * @param weight
	 * @return
	 */
	public Truck getTruck(double weight) {
		if(weight>=interval) {
			return new BigTruck("随机色");
		}else {
			return new SmallTruck("随机色");
		}
	}

}
//卡车类
class Truck{
	
	public Truck(String color2) {
		//构造方法传入参数对属性初始化
		this.color=color2;
		
	}
	public String color;
	public void transport() {
		System.out.println(this.color+"卡车在运货");
	}
}
class BigTruck extends Truck{
	
	public BigTruck(String colorr) {
		super(colorr);
	}
	public void transport() {
		System.out.println(color+"大卡车正在拉货");
	}
	public void lifting() {
		System.out.println("货运货物");
	}
}
class SmallTruck extends Truck{
	public SmallTruck(String color) {
		super(color);
	}
	public void transport() {
		System.out.println(color+"小卡车正在拉货");
	}
}

 二、抽象类

//抽象类使用abstract修饰
//抽象类用来被继承的
//抽象类可以继承实体类也可以继承抽象类

abstract class Animal{
    public void eat() {    
    }
}
public abstract class Dragon extends Animal {
    public void rain() {
        System.out.println("排风布雨");
    }

    
    //抽象类中可以定义 抽象方法 但是没有实际，没有方法体
    //继承抽象类的实体类必须实现抽象类中的抽象方法
    //抽象方法不能用private修饰

    public abstract void fly();
    public static void main(String[] args) {
        //new Dragon();
    }
}
class FireDragon extends Dragon{
        public void fly() {
        }
}
class WaterDragon extends Dragon{
    public void fly() {
    }
}
class Station{
    Dragon getDragon(int a) {
        if(a%2==0) {
            return new FireDragon();
        }else {
            return new WaterDragon();
        }
    } 

三、接口 

    //接口定义interface
public interface ICar {
    //接口中的属性是常量
    //接口中的量默认是常量  默认使用public static final来修饰
    //常量名要全部大写
    public static final int MAX=12;
    
    //接口中所有的方法都是抽象方法
    //在接口当中，定义抽象方法可以不写abstract
    //接口中定义的方法都是用public abstract来修饰的
    void run();
    
    //接口中可以拥有default修饰的实体方法
    //实例（对象）可以调用的方法
    //访问权限是public
    default void test() {}
}
interface ITest{
    void test1();
}
//类通过implements实现接口
//实现接口的类必须实现接口中定义的方法  一个类可以实现多个接口
class Truck1 implements ICar,ITest{
    int a=12;
    @Override
    public void run() {
    
    }
    @Override
    public void test1() {
    }
}
abstract class Truck2 implements ICar,ITest{
}
class Test extends Truck2{
    public void run() {
    }
    public void test1() {
    }
}
interface IEasy extends ICar,ITest{
}

四、关键字final 

    //关键字final
    //final修饰的类不可以被继承
    //用final修饰的量不能重新赋值
    //final修饰方法不可以被重写
    //抽象类 抽象方法不能被final修饰
    final String str;
    final int[] arr= {1,2,3};
    public Easy1(String code){
        str=code;
        //arr=new int[3];
        arr[0]=22;
    }
//    void test() {
//        str="张三";
//    }
    public static void main(String[] args) {
        Easy1 e1=new Easy1("123");
        System.out.println(e1.str);
        Easy1 e2=new Easy1("234");
        System.out.println(e2.str);
    }
}
 class A{
    public final void test() {
    }
}
class B extends A{
    //public void test(){
    //}
}

五、Static关键字

public class Easy4 {                        
    //使用static来定义类的属性和方法
    public static final int MAX=12;
    public static int count=22;
    public static void test() {
        System.out.println("静态的方法");
        //静态方法不能直接调用成员变量和方法
        //demo();
        Easy4 e4=new Easy4();
        e4.demo();
    }
    public void demo() {
        count=33;
        test();
    }                                                                    
}
class AA{
    public void a() {
        //通过类名调用静态的方法和属性
        Easy4.test();
        System.out.println(ICar.MAX);
    }
}

六、运行顺序

 //每次在运行构造方法前会运行普通代码块

public class Demo {
   
    public static void main(String[] args) {
        new B();
        new B();
}
}
class A{
    static{
        System.out.println("A========静态代码块");
    }
    {
        System.out.println("A====代码块");
    }
    A(){
        System.out.println("A=========");
    }
}
class B extends A{
    static{
        System.out.println("B========静态代码块");
    }
    {
        System.out.println("B====代码块");
    }
    B(){
        System.out.println("B==========");
    }
}

运行结果：

A========静态代码块
B========静态代码块
A====代码块
A=========
B====代码块
B==========
A====代码块
A=========
B====代码块
B==========