JAVA 2022.7.14课程总结

最新推荐文章于 2024-11-12 21:14:07 发布

HeyAmbition

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量230

点赞数

文章标签： java

本文链接：https://blog.csdn.net/Ambition011/article/details/125790687

版权

本文详细介绍了Java编程中的向上转型、抽象类、接口的使用，包括抽象方法、接口常量和默认方法。此外，还讨论了final关键字的作用，如不可变对象和防止方法重写，以及Static关键字的应用，如静态方法和静态变量。通过实例展示了这些概念在实际编程中的应用。

摘要由CSDN通过智能技术生成

一、向上转型
       //父类的指针可以指向子类的对象
       //子类的对象可以贴上父类的标签
       //只能调用指针类型中定义的方法
       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==========");
    }
}