java基础知识复习

已于 2023-04-24 19:30:55 修改
阅读量196 收藏
点赞数
文章标签： java 开发语言
于 2023-04-24 19:30:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_75052101/article/details/130349507
版权

面向对象

概念

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物（电视，洗衣机，车等），这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。
面向对象思想并不是一开始就有的，而是基于面向过程的基础之上演化过来的。面向过程的思想就是指问题的解决需要我们自己一步一步的去实现，使用的时候依次调用就可以了。面向对象则是把构成问题的事物按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。
面向对象的特点主要可以概括为封装性、继承性和多态性。

封装性

封装性是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。例如：用户使用电脑，只需要敲键盘就可以了，无需知道电脑内部是如何工作的，即使用户可能碰巧知道电脑工作原理，但在使用时，并不完全依赖电脑工作原理这些细节。

继承性

继承性主要描述的是类与类之间的关系，通过继承，可以在无需重写编写原有类的情况下，对原有类的功能进行扩展。

继承不仅增强了代码的复用性、提高开发效率，而且也减少了代码的重复性，还为程序的维护补充提供了便利。

多态性

多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其它类继承后，它们可以既有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。例如，当听到“Cut”这个单词时，理发师的行为是剪发，演员的行为表现是停止表演，不同的对象，所表现的行为是个一样的。

类与对象

类是对某一事物的抽象描述，而对象用于表示显示中国该类事物的个体。

定义

在面向对象的思想中最核心的就是对象，为了在程序中创建对象，首先需要定义一个类。类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，成员方法用于描述对象的行为，可简称为方法。

例题

/*
 * 描述人事物
 * 都是人的共性内容
 */
public class Dc {
	int age = 10;	//定义int类型变量age
	//定义speak()方法
	public void speak() {
		int age = 60;
		System.out.println("大家好，我今年" + age +"岁！");
	}
 
}

在Java，中定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。如果在某一个方法中定义的局部变量与成员变量同名，这种情况是允许的，此时方法和通过变量并访问到的是局部变量，而并非成员变量。

class Person{
                int age = 10;        //类中定义的变量被称作成员变量

                void speak() {
                                int age = 60;        //方法内部定义的变量被称作局部变量

                                System.out.println(“大家好，我今年“+age+”岁！”);

                }

}

上面的代码中，在Person类的speak（）方法中有一条打印语句，访问了变量age，此时访问的是局部变量age，也就是说当有另一个程序来调用speak（）方法时，输出的值为60，而不是10。

 对象的创建与使用

应用程序想要完成具体的功能，仅有类是远远不够的，还需要根据类创建实例对象，在Java程序中可以使用new关键词来创建对象。具体格式如下：

类名 对象名称 = new 类名();

创建Person类的实例对象代码如下：

Person p = new Person();

 上面的代码中，“newPerson()”用于创建Person类的一个实例对象，“Personp”则是声明了一个Person类型的变量p。中间的等号用于将Person对象在内存中的地址赋值给变量p，这样变量p便持有了对象的引用。
在实例化对象时，Java虚拟机会自动为成员变量进行初始化，针对不同类型的成员变量，Java虚拟机会赋予不同的初始值，如下表所示。

当对象被实例化后，在程序中可以通过对象的引用变量来访问该对象的成员，需要注意的是，当没有任何变量引用这个对象时，它将成为垃圾对象，不能再被使用。

类的设计

在Java中，对象是通过类创建出来的，因此，在程序设计时，最重要的就是类的设计。
假设要在程序中描述一个学校所有学生信息，可以先设置一个学生类(Student)，在这个类中定义两个属性name、age分别表示学生的姓名和年龄，定一个方法introduce()表示学生做自我介绍。具体如下：


public class Student {
        String name;      //定义一个姓名属性

        int age;               //定义一个年龄属性

        public void introduce() {
                //方法中打印属性name和age的值

                System.out.println("大家好，我叫" + name+ ",我今年" + age + "岁!");

        }

}
 

 封装类

在设计一个类时，应该对成员变量的访问作出一些限定，不允许外界随意访问,这就需要实现类的封装。
所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx方法和设置属性值的setXxx方法。

class Student{
  private String name;//将name属性私有化
  private int age;//将age属性私有化
  //下面的共有的方法间接访问类中的属性getXX方法，setXXX方法
  public String getName() {
   return name;
  }
  public void setName(String stuName) {
   name=stuName;
  }
  public int getAge() {
   return age;
  }
  public void setAge(int stuAge) {
   //下面是对传入的参数进行检查
   if(stuAge<0) {
    System.out.print("对不起，您输入的年龄不合法...");
   }else {
    age=stuAge;
   }
  }
  public void introduce() {
   System.out.println("大家好，我叫"+name+"，我今年"+age+"岁");
  }
 }
 public class Hello {
  public static void main(String[] args) {
  Student sut=new Student();
  Student stu;
  stu.setAge(-30);
  stu.setName("韩强");
  stu.introduce();
  }
}

案例：超市购物程序设计

/*商品类
 * 描述商品这个事物
 */
public class Demo6{
 private String proName;//商品名
 public String getproName() {
  return proName;
 }
 public void setproName(String proName) {
  this.proName=proName;
 }
}
/*
 * 定义超市类
 * 描述超市事物
 * 超市名字
 * 超市的仓库，存储商品
 * 售货方法
 */
public class Market {
 private String marketName;//超市名字
 private Demo6[] productArr;//仓库，存储商品，里面存储若干商品
 public String getMarketName() {
  return marketName;
 }
 public void setMarketName( String marketName) {
 this.marketName=marketName;
 }
 public  Demo6[] getProductArr() {
    return productArr;
    }
 public void setproductArr(Demo6[] productArr) {
  this.productArr=productArr;
 }
 public Demo6 sell(String name) {//卖货，指定商品名字
  for(int i=0;i<productArr.length;i++) {//循环遍历仓库中每一件商品
   if(productArr[i].getproName()==name) {//如果找到名字和要买的商品名字一样
    return productArr[i];//返回商品
   }
  }
  return null;
 }
}


/*
 * 定义人类
 * 描述人这个事物
 * 人的名字
 * 购物功能
 */
public class Person{
 private String name;//人名
 public String getName() {
  return name;
 }
public void setNme(String name) {
 this.name=name;
}
public Demo6 shopping(Market market,String name) {//购物，指定去哪个超市，商品名
 return market.sell(name);//调用超市的卖货方法，指定商品名字，把卖出去的或的结果返回
}
}
public class Shopping {
 public static void main(String[] args) {
  //创建商品对象，给商品名字赋值
  Demo6 p1=new Demo6();
  Demo6 p2=new Demo6();
  Demo6 p3=new Demo6();
  Demo6 p4=new Demo6();
  Demo6 p5=new Demo6();
  p1.setproName("电视机");
  p2.setproName("洗衣机");
  p3.setproName("豆浆机");
  p4.setproName("空调机");
  p5.setproName("吹风机");
  
  //创建超市对象，给超市名字赋值，给仓库赋值
  Market m=new Market();
  m.setMarketName("家乐福");
  m.setproductArr(new Demo6[] {p1,p2,p3,p4,p5});
  
  //创建购物者，给名字赋值
  Person p=new Person();
  p.setNme("小韩");
  //调用购物者的购物方法，指定超市商品，得到结果
  Demo6 result=p.shopping(m, "豆浆机");
  //根据结果进行判断
  if(result!=null) {
  System.out.println(p.getName()+"在"+m.getMarketName()+"买到了"+result.getproName());
 
 }else {
  System.out.println(p.getName()+"白跑一趟，在"+m.getMarketName()+"什么没买到");
 }
 }
}


 

 构造方法

定义

在一个类中定义的方法如果同时满足以下三个条件，该方法称为构造方法，具体如下:

  1. 方法名与类名相同
  2. 在方法名的前面没有返回值类型的声明
  3. 在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。

构造方法的重载

与普调方法一样，构造方法也可以重载，在一个类中可以定又多小构遗方法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以运过调用不同的构造方法来为不同的属性进行就值。

 this关键字

例如都声明为age。但是这样做又会导致成员变量 和局部变量 的名称冲突，在方法中将无法访问成员变量age。为了解决这个问题，Java中提供了一个关键字this来指代当前对象，用于在方法中访问对象的其他成员。this的作用就是区分成员变量和局部变量的同名情况。

垃圾回收

垃圾回收机制是指的就是对象，对象用完之后就变成垃圾了，那么它仍然会在内存当中，时间一长或者对象在垃圾的变成垃圾之后，过多会导致内存被占用被消耗，所以为了避免这种内存占用的情况，所以Java引入了垃圾回收机制。这个垃圾收取是一个自动行为，它会自动不定期的在内存当中收取这些对象。
除了等待Java虚拟机进行自动垃圾回收外，还可以通过调用Svstem.gc()方法来通知Java虚拟机立即进行垃圾回收。当一个对象在内存中被释放时，它的finalize()方法会被自动调用，因此可以在类中通过定义finalize()方法来观察对象何时被释放。

static关键字

静态变量

在定义一个类时，只是在描述某类事物的特征和行为，并没有产生具体的数据。只是通过new关键字创建该类的实例对象后，系统才会为每个对象分配空间，存储各自的数据。有时候，开发人员会希望某些特定的数据在内存中只有一份,而且能够被一个类的所有实例对象所共享。例如某个学校所有学生共享同一个学校名称，此时完全不必在每个学生对象所占用的内存空间中都定义一个变量来表示学校名称，而可以在对象以外的空间定义一个表示学校名称的变量，让所有对象来共享。

例题

package Package1;
/*
 * 静态变量
 */
class Student{
	static String schoolName; //定义静态变量schoolName
}
public class Test1 {
	public	static void main(String[] arge)throws Exception{
		Student stu1 = new Student(); //创建学生对象
		Student stu2 = new Student(); //创建学生对象
		//静态成员的调用方式，类名，对象
		Student.schoolName = "传智博客"; //为静态变量赋值
		System.out.println("我的学校是："+stu1.schoolName); //打印第一个学生对象的学校名
		System.out.println("我的学校是："+stu2.schoolName); //打印第一个学生对象的学校名
	}
 
}

 静态方法

在实际开发时，开发人员有时会希望在不创建对象的情况下就可以调用某个方法，换句话说也就是使该方法不必和对象绑在一起。要实现这样的效果，只需要在类中定义的方法前加上static关键字即可，通常称这种方法为静态方法。同静态变量一样，静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。
注意:在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

例题

package Package1;
/*
 * 静态方法的使用
 */
class Person{
	public static void sayHello() { //定义静态方法
		System.out.println("hello");
	}
}
public class Test1 {
	public	static void main(String[] arge)throws Exception{
		//1 类名。方法的方式调用方法
		Person.sayHello();
		//2 实例化对象的方式调用静态方法
		Person p = new Person();
		p.sayHello();
		
	}
 
}

静态代码块

在Java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行由于类只加载一次，因此静态代码块只执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化；

例题

成员内部类

成员内部类
在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。

  1. 根据内部类的位置、修饰符和定义的方式可分为:成员内部类、静态内部类、方法内部类。
  2. 在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。在成员内部类中，可以访问外部类的所有成员。

如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象创建内部类对象的具体语法格式如下:


外部类名.内部类名 变量名 = new 外部类名 ().new 内部类名();

案例篇：银行新用户现金业务办理

/*
 * 定义银行类
 * 属性：银行名称，储户名称，密码，余额，交易额度
 * 功能：开门营业，存钱，取钱，关门
 */
public class Bank {
	static String bankName;//定义静态变量银行名字
	private String name;//储户姓名
	private String password;//密码
	private double balance;//账户余额
    private double turnover;//交易额
    //静态方法，打出银行的欢迎语句
    public static void welcome() {
    	System.out.println("欢迎来到"+bankName+"------------");
    }
    public Bank(String name,String password,double balance,double turnover) {
		super();
		this.name = name;
		this.password = password;
		this.balance = turnover;
		this.turnover = turnover-10;
		System.out.println(name+"开户成功，账户余额"+balance);
	}
    //存款功能
    public void deposit(double turnover) {
    	balance=balance+turnover;
    	System.out.println(name+"您好，你的账户已经存入"+turnover+"元"+"当前余额"+balance+"元");
    }
    //取款功能
    public void withdrawal(String password,double turnover) {
    //根据传入的变量与成员变量对比，判断密码是否正确
    if(this.password!=password) {
    	System.out.println("您输入的密码错误");
    	return;
    }
    //判断余额是否充足
    if(balance-turnover>0) {
    	balance=balance-turnover;
    	System.out.println(name+"您好，您的账户已取出"+turnover+"元，当前余额"+balance+"元");
}else {
	System.out.println("对不起，账户余额不足");
}
}
    //静态方法，打印出银行欢迎下次光临
    static void welcomeNext() {
    	System.out.println("请携带好随身财物，欢迎下次光临"+bankName+"----------------");
    }
}
 
 
public class Demo6{
	public static void main(String[] args) {
		//定义一家银行，给静态变量（银行名字）赋值，类名.调用成员变量
		Bank.bankName="招商银行";
		//银行的打印欢迎光临语句，调用静态方法
		Bank.welcome();
		//开户操作通过调用构造方法进行开户
		Bank bank=new Bank("小梦","654321",100, 0);
		//进行存款操作
		bank.deposit(500);
		//取款时密码输入错误，取款失败
		bank.withdrawal("123456",200);
		//取款时余额不足，取款失败
		bank.withdrawal("654321",1000);
		//取款时密码正确，余额充足，取款成功
		bank.withdrawal("654321",200);
		//银行打印到别语句，调用静态方法
		Bank.welcomeNext();
		
	}
}

类的继承

概念

在程序中，继承描述的是事物之间所属关系，通过继承可以使多种事物之间形成一种关系体系。

      在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一类，需要使用extends关键字。

在类的继承，需要注意一些问题，具体如下：

  1. 在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个父类，但是多个类可以继承一个父类
  2. 在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类
  3. 在Java中，子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法

重写

在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。需要注意的是，在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。

super关键字

当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，在Java中专门提供了一个super关键字用于访问父类的成员。

1、使用super关键字访问父类的成员变量和成员方法。具体格式如下：

super.成员变量

super.成员方法（[参数1，参数2...])

2、使用super关键字访问父类的构造方法，具体格式如下：

super（[参数1，参数2...])

 final关键字

Java中的类被final关键字修饰后，该类将不可以别继承，也就是不能够派生子类。

final关键字可用于修饰类、变量和方法，它有“无法改变”或者“最终”的含义，因此被final修饰的类、变量和方法将具体有以下特性：

  1. final修饰的类不能被继承
  2. final修饰的方法不能被子类重写
  3. final修饰的变量（成员变量和局部变量）是常量，只能复制一次 

抽象类和接口 

抽象类

当定义一个类时，常常需要定义一些方法来描述该类的行为特征，但有时这些方法的实现方式是无法确定的。

      针对上面描述的情况，Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰，具体实例如下：

abstract  void shout();   //定义抽象方法shout（）

 当一个类中包含了抽象方法，该类必须使用abstract关键字来修饰，使用abstract关键字修饰的类为抽象类。

      在定义抽象类时需要注意，包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需要使用abstract关键字来修饰即可。

另外，抽象类是不可以被实例化的，因为抽象类中可能包含抽象方法，抽象方法是没有方法体的，不可以被调用。如果想调用抽象类中定义的方法，则需要创建一个子类，在子类中将抽象类中的抽象方法进行实现。

接口

  如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。

接口是由常量和抽象方法组成的特殊类，是对象类的进一步抽象。

     在定义接口时，需要使用interface关键字来声明，其语法格式如下：

public  interface  接口名  extrends  接口1，接口2...

public static  final  数据类型   常量名=常量值；

public  abstract 返回值  抽象方法名（参数列表）；

     在上面的语法中，一个接口可以有多个父接口，他们之间用逗号隔开。Java使用接口的目的是为了克服单继承的限制，因为一个类只能有一个父类，而一个类可以实现多个接口。

      由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法。此时需要定义一类，并使用implements关键字实现接口中所有的方法。一个类可以在继承的同时实现多个接口，在implements子句中用逗号隔开。接口的实现类声明格式如下：

修饰符  class 类名  extends  超类名  implements  接口1，接口2,...

USB接口程序设计代码案例

/*
 * 定义一个名为USB的接口
 */
public interface USB {
	public void turnOn();
	public void turnOff();
}
 
 
/*
 * 电脑类
 * 有很多USB插槽
 * 连接USB设备功能
 * 开机功能，关机功能
 */
public class Computer {
	//电脑上的USB插槽
	private USB[] usbArr=new USB[4];
	//向电脑上连接USB设备
	public void add(USB usb) {
		//遍历数组，获取所有的插槽
		for(int i=0;i<usbArr.length;i++) {
			if(usbArr[i]==null) {
				//将设备连接在USB插槽上
				//将USB接口实现类对象，存储到USB数组中
				usbArr[i]=usb;
				break;
			}
			}
		}
	//电脑的开机功能
	public void powerOn() {
		//循环遍历所有插槽
		for(int i=0;i<usbArr.length;i++) {
			//如果发现数组中存储了USB接口实现对象
			if(usbArr[i]!=null) {
				//调用设备上的开启功能
				usbArr[i].turnOn();
			}
		}
		System.out.println("电脑开机成功");
	}
	//电脑关机功能
	public void powerOff() {
		for(int i=0;i<usbArr.length;i++) {
			if(usbArr[i]!=null) {
				usbArr[i].turnOff();
			}
		}
		System.out.println("电脑关机成功");
	}
}
 
 
/*
 * 键盘
 */
public class KeyBoard implements USB {
	public void turnOn() {
	System.out.println("键盘启动");	
	}
	public void turnOff() {
	System.out.println("键盘关闭");			
	}
}
 
 
 
/*
 * 鼠标
 */
public class Mouse implements USB {
	public void turnOn() {
		System.out.println("鼠标启动");		
	}
	public void turnOff(){
		System.out.println("鼠标启动");		
	}
 
}
 
 
/*
 * 麦克风
 */
public class Mic implements USB {
	public void turnOn() {
		System.out.println("麦克风启动");	
	}
	public void turnOff() {
		System.out.println("麦克风键盘启动");	
	}
}
 
 
/*
 * 测试类
 */
public class Demo6{
	public static void main(String[] args) {
		//创建电脑对象
		Computer c=new Computer();
		//向电脑中添加USB设备，鼠标，麦克风和键盘设备
		c.add(new Mouse());
		c.add(new Mic());
		c.add(new KeyBoard());
		c.powerOn();//调用电脑的启动
		System.out.println();
		c.powerOff();//调用电脑的关机方法		
	}
}


 

 多态


概念 

在同一个方法中，这种由于参数类型不同而导致执行效果各异的现象就是多态。继承是多态得以实现的基础。

       在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。

多态的类型转换

将子类对象当作父类类型的情况，Java的语言环境中称为“向上转型”。

      将子类对象当作父类使用时不需要任何显式声明，需要注意是的，此时不能通过父类变量去调用子类中的特有方法。

      向上转型子类提升父类，实现类提升为了接口类型。如果调用实现类或者是子类中的特有方法，类型的向下转型，数据类型的向下转型，需要强制转换

      多态的好处对父类或者接口提供程序的扩展性，坏处能调用子父类的共有属性，不能调有子类的特有属性。

Object类

  Object类是层次结构的根类，每个类都直接或间接继承自该类，所有对象（包括数组P）都实现了这个类的方法

   方法说明

方法名称    方法说明
equals() 指定其他某个对象是否与此对象“相等”
getClass()   返回此 Object的运行时类
hashCode()返回该对象的哈希码值
toString() 返回该对象的字符串表示


匿名内部类

在编写Java程序时，在类里面定义的类称之为内部类，内部类时外部类的一个成员。Java内部类可以分为：成员内部类、方法内部类和匿名内部类等。

      如果方法的参数被定义为一个接口类型，那么就需要定义一个类来实现接口，并根据该类进行对象实例化。除此之外，还可以使用匿名内部类来实现接口。当程序中使用匿名内部类时，在定义匿名内部类的地方往往直接创建该类的一个对象。

模拟物流快递系统程序设计代码案例

 
package cn.itcast.chapter04.task02;
 
public interface Careable {
public abstract void upKeep() ;
}
 
 
package cn.itcast.chapter04.task02;
 
public interface GPS {
 public String showcoordinate();
}
 
 
package cn.itcast.chapter04.task02;
 
public class phone implements GPS {
 
 
	public phone() {
		super();
		
		}
 
	public String showcoordinate() {
		String location="193,485";
		return location;
	}
 
	
	}
 
 
 
 
package cn.itcast.chapter04.task02;
 
public class SendTask {
	private String number;
	private double goodsweight;
	
	public SendTask() {
		super();
	}
 
	public SendTask(String number, double goodsweight) {
		super();
		this.number = number;
		this.goodsweight = goodsweight;
	}
	public void sendBefore() {
		System.out.println("订单开始处理，仓库验货中...");
		System.out.println("货物重量："+this.getGoodsweight()+"公斤");
		System.out.println("货物检验完毕");
		System.out.println("货物填装完毕");
		System.out.println("快递单号："+this.getNumber());
		
		
		
	}
	public void send(Transportation t,GPS tool) {
		System.out.println("运货人"+t.getAdmin()+
				"正在驾驶编号为"+t.getNumber()+
				"的"+t.getModel()+"发送货物！");
	t.transport();
	String showCoordinte=tool.showcoordinate();
	String showCoordinate;
	System.out.println("货物当前的坐标为："+showCoordinte);
	}
	public void sendAfter(Transportation t) {
		System.out.println("货物运输任务已完成");
		System.out.println("运货人"+t.getAdmin()+"所驾驶的编号为"+t.getNumber()+"的"+t.getModel()+"已归还");
		
	}
 
	public String getNumber() {
		return number;
	}
 
	public void setNumber(String number) {
		this.number = number;
	}
 
	public double getGoodsweight() {
		return goodsweight;
	}
 
	public void setGoodsweight(double goodsweight) {
		this.goodsweight = goodsweight;
	}
	
}
 
package cn.itcast.chapter04.task02;
 
public class Task02Test {
 
	public static void main(String[] args) {
		SendTask task=new SendTask("HYX600235",76.34);
		task.sendBefore();
		System.out.println("===================");
		ZTransportation t=new ZTransportation("2025","大奔","小韩");
		phone p=new phone();
		task.send(t, p);
		System.out.println("====================");
		task.sendAfter(t);
		t.upKeep();
	}
 
}
 
 
package cn.itcast.chapter04.task02;
 
public abstract class Transportation {
private String number;
private String model;
private String admin;
public Transportation() {
	super();
}
public Transportation(String number, String model, String admin) {
	super();
	this.number = number;
	this.model = model;
	this.admin = admin;
}
public abstract void transport();
public String getNumber() {
	return number;
}
public void setNumber(String number) {
	this.number = number;
}
public String getModel() {
	return model;
}
public void setModel(String model) {
	this.model = model;
}
public String getAdmin() {
	return admin;
}
public void setAdmin(String admin) {
	this.admin = admin;
}
 
}
 
 
package cn.itcast.chapter04.task02;
 
public class ZTransportation extends Transportation implements Careable{
 
	
	public ZTransportation() {
		super();
		
	}
 
	public ZTransportation(String number, String model, String admin) {
		super(number, model, admin);
	}
 
	public void transport() {
		System.out.println("运输进行中...");
	}
 
	
	public void upKeep() {
		System.out.println("货物运输车辆保养完毕!");
	}
 
}

哪错了？
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值