20220714课堂笔记

上午

一、0713作业讲解

package com.easy0714;
​
public class Easy {
​
    public static void main(String[] args) {
        Truck t1 = new Truck("red");//等价于    t1.color = "red";
        t1.transport();
​
        Truck t2 = new Truck("green");//等价于    t2.color = "green";
        t2.transport();
        
       
        Big_Truck bt1 = new Big_Truck("pink");
        bt1.transport();
        Small_Truck st1 = new Small_Truck("brown");
        st1.transport();
​
        
        //向上转型
        //父类的指针可以指向子类的对象
        //子类的对象可以贴上父类的标签
        //只能调用、执行指针类型中定义的方法
        Truck/*父类的指针*/ bt2 = new Big_Truck/*子类的对象*/("white");
        bt2.transport();
​
        Truck st2 = new Small_Truck("black");
        st2.transport();
​
        Easy easy = new Easy();//实例化Easy（即Station）
​
        double weight;
        for (int i = 0; i <20 ; i++) {
            weight = Math.random()*100;
            System.out.println(weight);
            easy.start(weight);//调用Easy（station）的strat方法
        }
    }
    double interval = 50;
    /** 根据货重  调度卡车（大卡车、小卡车）
     *
     * @param weight
     * @return
     * */
    public Truck getTruck(double weight){
    if (weight>=interval){
        return new Big_Truck("随机色");
            }
    else {
        return new Small_Truck("任意色");
    }
    }
​
​
    public void start(double weight){
        Truck s = getTruck(weight);
        s.transport();
    }
}
​
class Truck{
​
    public Truck(String color ){//构造方法传入参数对属性初始化
        this.color=color;
    }
​
    public String color;
​
    public void transport(){
        System.out.println(color+"卡车在运货");
​
    }
}
​
class Big_Truck extends Truck {
    public Big_Truck(String color) {
        super(color);
    }
    public void transport(){
        System.out.println(super.color+" Big truck is in transit");
    }
    public void lift(){
        System.out.println("货物搬运");
    }
}
​
​
class Small_Truck extends Truck{
    public Small_Truck(String color){
        super(color);
    }
    public void transport(){
        System.out.println(super.color+" Small truck is in transit");
    }
}

 

下午

二、抽象类

1.抽象类使用abstract修饰 主要作用是被继承

2.抽象类中可以定义抽象方法

3.抽象方法 ： 有该方法的定义 但是没有实现（没有实际的动作、行为 即没有方法体）

4.继承抽象类的实体类 必须实现抽象类中的抽象方法

5.实例

package com.easy0714_2;
​
abstract class Animal {
    public void eat(){
​
    }
}
public abstract class Dragon extends Animal{
​
    public void rain(){
        System.out.println("哗啦啦");
    }
    public abstract void  fly();
​
    
    public static void main(String[] args) {
        Fire_Dragon F = new Fire_Dragon();//实例化一个火龙对象
        F.fly();
        F.rain();
        
        //调用Get_Dragon方法  根据传入的值决定调用那一条龙
        int x=2;
        Station s = new Station();
        Dragon d =  s.Get_Dragon(x);
        d.fly();
        d.rain();
    }
}
​
class Fire_Dragon extends Dragon{
    @Override
    public void fly() {
        System.out.println("刷刷刷");
    }
    public void rain(){
        System.out.println("火龙不会下雨");
    }
}
​
​
class Water_Dragon extends Dragon{
​
    @Override
    public void fly() {
        System.out.println("飞");
    }
​
}
​
class Station{//定义龙类管理类
​
    Dragon Get_Dragon(int a){//决定龙的调用方法
        if (a%2==0){
            return new Fire_Dragon();
        }
        else {
            return new Water_Dragon();
        }
    }
}

 

 

三、接口

1.接口的属性是常量（常量名要全部大写）

2.接口的量默认是常量 使用public static final来修饰

3.接口中所有的方法都是抽象方法

4.接口中默认所有的方法都是使用public abstract 来修饰的

5.定义抽象方法可以不写abstract

6.接口中可以有default修饰的实体方法

7.实例可以调用方法

8.类通过implements实现接口

9.实现接口的类 必须实现接口中定义的抽象方法

10.实例

package com.easy0714_2;
​
public interface ICar {
    int MAX =10789;//接口中常量  <==>  public static final int MAX =1;
    int b = 566;//常量
   
    void run(); //定义抽象方法 abstract可以省略
​
    default void test(){}
    //default在这里的访问权限  等价于  public
    default void test1(){}
}
​
interface ITest{
  default void test3(){
    }
}
​
class Truck implements ICar{
    //Truck类要实现ICar接口
    int a =12;//变量
    @Override
    public void run() {//实现ICar中的抽象方法run()
        test();
    }
}
​
abstract class Truck2 implements ITest,ICar{
    //一个类可以同时实现两个接口
    @Override
    public void run() {
        
    //必须实现ICar中的run()方法  不然下面的Test类无法继承
    //如果不在这里实现  也可以在Test类中实现run()方法
    }
    @Override
    public void test1() {
    }
}
​
class Test extends Truck2{
​
}
interface IEasy extends ITest,ICar{
​
}

 

 

四、关键字final

1. final修饰的类不可以被继承

2. final修饰的量不可以被重新赋值

3. final修饰的方法不可以被重写

4.实例

package com.easy0714_3;
​
import java.util.Arrays;
​
public class Easy {
​
    final String  str;
    //final修饰的量不可以被重新赋值
    //但是可以修改地址所指向的值的内容
    final int[] arr={1,2,3};
    public Easy(String code){
        str = code;
        arr[1]=5;//修改final arr中下标为0的元素
    }
    
    public static void main(String[] args) {
        Easy e1 = new Easy("123");
        Easy e2 = new Easy("456");
        System.out.println(e1.str);
        System.out.println(e2.str);
        System.out.println(Arrays.toString(e1.arr));
    }
}
​

 

五、关键字static

1.使用static定义类的属性和方法

 

package com.easy0714_3;
​
import com.easy0714_2.ICar;
​
public class Easy2 {
    //使用static定义类的属性和方法
    public static final int MAX = 12;
    public static int count = 22;
    public static void test(){
        //静态方法不能直接调用成员变量和方法
        System.out.println("静态的方法");
        Easy2 e2 = new Easy2();
        //实例化后可调用成员变量和方法
        e2.demo();
    }
​
    public void demo(){
        System.out.println(MAX);
        count=33;
        test();
    }
    public static void main(String[] args) {
        AA a = new AA();
        a.A();
    }
}
class AA{
    public void A(){
        Easy2.test();//通过类名直接调用静态方法和属性
        System.out.println(ICar.MAX);
        System.out.println(long.class.getTypeName()+int.class.getTypeName());
    }
}

 

 

 

 

六、代码的执行顺序

 

1. 父类静态变量和静态代码块（先声明的先执行）；

2. 子类静态变量和静态代码块（先声明的先执行）；

3. 父类的变量和代码块（先声明的先执行）；

4. 父类的构造函数；

5. 子类的变量和代码块（先声明的先执行）；

6. 子类的构造函数。

package com.easy0714_3;
​
public class Demo {
    public static void main(String[] args) {
        new Y();
        new Y();
    }
}
​
class Z{
    static {
        System.out.println("A的静态代码块------");
    }
    //每次在运行构造方法前  会运行普通代码块
    {
        System.out.println("A中的代码块---------------");
    }
    Z(){
        System.out.println("A----------------");
    }
}
class Y extends Z{
    static {
        System.out.println("B的静态代码块------");
    }
    {
        System.out.println("B中的代码块---------------");
    }
    Y(){
        System.out.println("B----------------");
    }
}

 

20220714课后作业

用接口实现的方法完成卡车货运站问题

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

 

1.定义卡车接口并实现

package com.task071401;
​
public interface Truck {
    public void transport();
}
​
class Big_truck implements Truck{
    public void transport(){
        System.out.println("Big truck is in transit");
    }
​
}
class Small_Truck implements Truck{
    public void transport(){
        System.out.println("Small Truck is in transit");
    }
}

2.定义Station类和他的方法

package com.task071401;
public interface Station {
    /*public static final*/ int INTERVAL = 20;//常量
    //定义两个抽象方法dispatch & deliver
    public Truck dispatch(int weight);
    public void deliver(Truck a);
}
class Station1 implements Station {
    @Override
    public Truck dispatch(int weight) {
        //实现Station的抽象方法dispatch
        if (weight <= INTERVAL) {
            return new Small_Truck();//返回小卡车类型对象
        } else {
            return new Big_truck();//返回大卡车类型对象
        }
    }
    @Override
    public void deliver(Truck a) {
        //实现Station的抽象方法deliver
        a.transport();//根据传入的卡车类型  
        //调用他的transport方法
    }
    public static void main(String[] args) {
        Station s = new Station1();//实例化Station
        for (int i = 0; i < 20; i++) {
            int weight = (int) (Math.random() * 100);
            System.out.println(weight);
            s.dispatch(weight).transport();
            //将weight传入dispatch方法返回一个卡车对象类型
            //根据卡车对象类型  调用他的transport方法
        }
    }
}

 

标签：20220714,void,System,笔记,Truck,println,课堂,public,out
来源： https://www.cnblogs.com/qq1078973635/p/16479030.html