第二遍Java基础知识复习

目录

面向对象的概念

类和对象

类的定义

对象的创建与使用

类的设计

类的封装

案例篇：超市购物程序设计

构造方法的定义

构造方法的重载

this关键字的使用

垃圾回购机制

静态变量

静态方法

静态代码块

​编辑

成员内部类

银行新用户现金业务办理

​编辑

继承的概念

重写父类方法 

super关键字

​编辑

final关键字

抽象类

接口

USB接口程序设计

​编辑

多态的概述

Object类

匿名内部类

模拟物流快递系统程序设计

​编辑

---

面向对象的概念

• 面向对象是一种符合人类思维习赏的编理息想，现实生活中存在各种形恋不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象亲肤射现实中的事物，使用对象的关系来搞述事物之间的联系，这种思想就是面向对象。
•  提到面向对象，自然会想到面向过程，面向过理就是分析出解决问题所篱要的步想，然后用函数把这些步想一一实现，使用的时候依次调用就可以了。酉向对急则是把构成问题的事务按照一定规则划分为多个独立的对象然后通过询用对象的方法来解决问题。当然，一个应用短序会包含多个对象，通过多个对象的相互配合来实现应用程序的功能，这样当应用程序功能发生变动时，只禽要修改个别的对象就可以了，从而使代码更容易得到缝护，面向对象的够点主要可以概括为封装性、继承性和多态性，接下来针对这三种将性进行简单介绍。
• 面向对象的特点主要可以概括为封装性、继承性和多态性。

1、封装性

     封装性是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节。

2、继承性

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

3、多态

      多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，使得同一个属性和方法在不同类中具有不同的语义。

类和对象

面向对象的编程思想，力图让程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点，面对象的思想中提出了两个概念，即类和对象。类是对某一类事物的抽象描述，对象是用于表示现实中该类事物的个体。

类的定义

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

代码示例：

/*
 * 描述人事物
 * 都是人的共性内容
 */
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关键字的使用

  this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用。

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

垃圾回购机制

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

静态变量

      在定义一个类时，只是在描述某类事物的特征和行为，并没有产生具体的数据。只有通过new关键字创建该类的实例对象后，系统才会为每个对象分配空间，存储各自的数据。

 在Java类中，可以使用static关键字来修饰成员变量，该变量被称为静态变量。静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。

静态方法

在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

静态代码块

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

package Package1;
/*
 * 静态代码块
 */
class Person{
	//静态代码块
	static {
		System.out.println("Person类中的静态代码块执行了");
	}
 
}
public class Test1{
	//静态代码块
		static {
			System.out.println("测试类中的静态代码块执行了");
		}
		public static void main(String[] args) throws Exception{
			//下面代码创建两个Person对象
			Person p1 = new Person();
			Person p2 = new Person();
			
		}
}

成员内部类

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

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

外部类名.内部类名.变量名=new  外部类名（）.new  内部类名（）；

银行新用户现金业务办理

/*
 * 定义银行类
 * 属性：银行名称，储户名称，密码，余额，交易额度
 * 功能：开门营业，存钱，取钱，关门
 */
public class Tas {
 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关键字。

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

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

重写父类方法 

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

super关键字

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

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

super.成员变量

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

/*
 * super关键字
 * 子类中，访问父类的成员
 * 父类成员变量，和父类的成员方法
 */
//定义Animal作为父类
class Animal{
 String name="+动物";
 //定义动物叫的方法
 public void shout() {
 System.out.println("动物发出叫声");
 }
}
//定义Dog类继承Animal父类
class Dog extends Animal{
 String name="犬类";
 //重写父类的方法shout
 public void shout() {
  //访问父类的方法shout（）
  //super.父类方法（）
  super.shout();
 }
 //定义打印机name属性的方法
 public void printName() {
  System.out.println("name"+super.name);//访问父类的成员变量name
 }
}
public class Hello {
  public static void main(String[] args) {
   Dog dog=new Dog();//创建Dog类对象，子类对象
   dog.shout();//调用Dog类中的方法about
   dog.printName();//调用Dog类的方法printName
  }
}

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

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

/*
 * super（）访问父类的构造方法
 */
//定义一个Animal类作为父类
class Animal{
 public Animal() {
  System.out.println("我是一只动物");
 }
 public Animal(String name) {
  System.out.println("我是一只"+name);
 }
}
//定义Dog类继承父类
class Dog extends Animal{
 public Dog() {
  System.out.println("沙皮狗");
 }
 
}
//定义测试类
public class Hello {
  public static void main(String[] args) {
   Dog dog=new Dog();//创建Dog类的对象，子类对象
  }
}

final关键字

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

• final修饰的类不能被继承
• final修饰的方法不能被子类重写
• 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接口程序设计

package cn.itcast.chapter04.task01;
 
public class computer {
 private USB[]usbArr=new USB[4];
 public void add(USB usb) {
  for(int i=0;i<usbArr.length;i++) {
   if(usbArr[i]==null) {
    usbArr[i]=usb;
    break;
   }
  }
 }
 
 
 
 public void poweron() {
  for(int i=0;i<usbArr.length;i++) {
   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("电脑关机成功");
 }
}

package cn.itcast.chapter04.task01;
import static  java.lang.System.out;
public class KeyBoard implements USB{
 public void turnon() {
  out.println("键盘启动了");
 }
 public void turnoff() {
  out.println("键盘关闭了");
 }
}

package cn.itcast.chapter04.task01;
 
public class Mic implements USB {
 
 
 public void turnon() {
  System.out.println("麦克风启动了");
 }
 
 
 public void turnoff() {
  System.out.println("麦克风关闭了");
 }
 
 
 
}

package cn.itcast.chapter04.task01;
 
public class Mouse implements USB {
 
 public void turnon() {
  System.out.println("鼠标启动了");
 }
 
 
 public void turnoff() {
  System.out.println("鼠标关闭了");
 }
 
 
}

package cn.itcast.chapter04.task01;
 
public class Task01Taxt {
 public static void main(String[]args) {
  computer c=new computer();
  c.add(new Mouse());
  c.add(new Mic());
  c.add(new KeyBoard());
  c.poweron();
  System.out.println();
  c.poweroff();
  System.out.println();
 }
}

package cn.itcast.chapter04.task01;
 
public interface USB {
 public void turnon();
   public void turnoff();
}

多态的概述

在设计一个方法时，通常希望该方法具备一定的通用性。多态的前提是要有继承，要有方法的重写。我们可以把它理解为一个事物具备的多种形态，称之为多态。比如说一个人，在不同的时期和不同的环境下它所表现出来的状态，或者形态是不一样的。在同一个方法中，参数类型不同而导致出现的运行结果也不同，那就产生出这种多态的现象。
在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。接口的引用等于它的一个实现类的对象，这个实现类是可以有不同的子类。它有利于我们程序的扩展性的出现。

package Package1;
/*
 * 对象的多态性
 * 父类或者是接口引用 = new 子类的对象
 */
 
//定义接口Animal
interface Animal{
	public static void shout() {
		// TODO Auto-generated method stub
		
	} //定义抽象方法
}
 
//定义Cat类实现Animal接口
class Cat implements Animal{
	//实现shout方法
	public void shout() {
		System.out.println("喵喵...");
	}
}
 
//定义Dog类实现Animal接口
class Dag implements Animal{
	//实现shout方法
	public void shout() {
		System.out.println("汪汪...");
	}
}
//定义测试类,多态
public class Test1{
	public static void main(String[] args) throws Exception{
			//下面代码创建两个Person对象
			Animal an1 = new Cat(); //创建Cat对象，使用Animal类型的变量an1引用
			Animal an2 = new Cat(); //创建Cat对象，使用Animal类型的变量an1引用
			animalShout(an1); //调用animalShout()方法，将an1作为参数传递
			animalShout(an2); //调用animalShout()方法，将an2作为参数传递
		}
	//定义静态的animalShout方法 ，接受一个Animal类型的参数
	//参数，可以接受的是Animal接口的任何实现类对象
	public static void animalShout(Animal an) {
		Animal.shout(); //调用实际参数的shout()方法
	}
}

 多态的类型转换

1、将子类对象当中父类对象类型使用的情况，这在Java语言环境中称为“向上转型”
2、将子类对象当中父类对象使用时不需要任何显式的声明，需要注意的是，此时不能通过父类变量去调用子类中特有的方法

package Package3;
/*
 * 多态中的转型
 */
 
//定义Animal接口
interface Animal{
	public abstract void shout(); //定义抽象
}
 
//定义Cat类实现Animal接口
class Cat implements Animal{
	//实现抽象方法shout()
	public void shout() {
		System.out.println("喵喵...");
	}
	//定义sleep()方法
	public void sleep() {
		System.out.print("猫睡觉...");
	}
}
 
//定义测试类
public class Tas {
 
	public static void main(String[] args) {
		Cat cat = new Cat(); //创建Cat类的对象
	}
 
	//定义静态方法animalShout()，接收一个Animal类型的参数
	public static void animalShout(Animal animal) {
		animal.shout(); //调用传入参数animal的shout（）方法
		//animal.sleep(); //不能调用子类的特有方法
	}
}

作用：可以对父类这个接口提升程序的扩展性
弊端：不能调用子类特有的方法，只能调用子父类的共有内容

Object类

在jdk中提供了一个Object类，它是类层次结构的根类，每个类都直接或间接继承自该类，所有对象包括数组都实现了这个类的方法常用方法

匿名内部类

 在编写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("货物运输车辆保养完毕!");
 }
 
}