第二篇Java核心技术复习

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物和各种联系，在程序中使用对象映射现实中的事物和关联这就是面向对象。面向对象是把构成问题的事物按照一定的规则划分为多个独立对象，然后通过调用对象的方法来解决问题。一个应用程序会包含多个对象通过对象相互配合来实现应用程序的功能，这样就应用程序功能发生变动时只需修改个别对象就好了。使代码更容易得到维护。

面向过程：就是分析出解决问题所需的步骤，然后用函数把这些步骤一一实现，使用时依次调用就好了。

面向对象的特点：封装性，继承性，多态性。

1.封装性

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

2.继承性

继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。如，有一个汽车的类，该类中描述了汽车的普通特性和功能，而轿车的类中不仅应该包含汽车的特性和功能，还应该增加轿车特有的功能，这时，可以让轿车类继承汽车类，在轿车类中单独添加轿车特性的方法就可以了。继承不仅增强了代码的复用性、提高开发效率，还为程序的维护补充提供了便利。

3.多态性

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

3.2类与对象

类的定义

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

在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虚拟机会赋予不同的初始值。

成员变量	初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0D
char	空字符，"\U000"
boolean	false
引用数据类型	mull

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

类的设计

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

public class Student {
        String nane;//定义一个姓名属性
        int age; //定义一个年龄属性
        public void introduce (){
//方法中打印属性name和age的值
System.out.princln（"大家好，我叫"+ name+"，我今年”+age+"岁）;

        }

}

类的封装

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

案例：

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();
  }
}

3-1超市购物程序设计代码：

package cn.itcast.chapter03.task01;
/*
 * 定义超市类
 * 描述超市事物
 * 超市名字
 * 超市的仓库，存储商品
 * 售货方法
 */
public class Market {
 private String MarketName;//超市名字
 private Product[]productArr;//仓库，存储商品，里面存储若干商品
 private Product nu11;
 public String getMarketName() {
  return MarketName;
  
 }
 public void setMarketName(String MarketName) {
  this.MarketName=MarketName;
 }
 public Product[] getProductArr() {
  return productArr;
  
 }
 public void setproductArr(Product[]ProductArr, Product[] productArr) {
  this.productArr=productArr;
 }
 public Product sell(String name) {//卖货，指定商品名字
  for (int i=0;i<productArr.length;i++) {//循环遍历仓库中每个商品
   if (productArr[i].getProName()==name) {//如果找到名字和要买的商品名字一样
    return productArr[i] ;//返回商品
   }
  }
  return nu11;
 }
 public void serproductArr(Product[] products) {
  // TODO Auto-generated method stub
  
 }
}


package cn.itcast.chapter03.task01;
/*
 * 定义人类
 * 描述人的这个事物
 * 人的名字
 * 购物功能
 */
public class Person {
 private String name;//人名
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name=name;
 }
 public Product shopping (Market market,String name) {//购物，指定去哪个超市，商品名
  return market.sell(name);//调用超市的卖货方法，指定商品名字，把卖出的货的结果返回
 }
}


package cn.itcast.chapter03.task01;
/*
 * 商品类
 * 描述商品这个事物
 */
public class Product {
 private String proName ;//商品名
 public String getProName() {
  return proName;
 }
 public void setProName(String proName) {
  this.proName=proName;
 }

}


package cn.itcast.chapter03.task01;

public class Shopping {

 public static void main(String[] args) {
  // 创建商品对象，给商品名字赋值
  Product p1=new Product();
  Product p2=new Product();
  Product p3=new Product();
  Product p4=new Product();
  Product p5=new Product();
  p1.setProName("电视机");
  p2.setProName("洗衣机");
  p3.setProName("豆浆机");
  p4.setProName("空调机");
  p5.setProName("吹风机");
  //创建超市对象，给超市名字赋值，给仓库赋值
  Market m=new Market();
  m.setMarketName("家乐福");
  m.serproductArr(new Product[] {p1,p2,p3,p4,p5});
  //创建购物者，给名字赋值
  Person p=new Person();
  p.setName("小韩");
  //调用调用者的购物方法，指定超市商品，得到结果
  Product result=p.shopping(m, "豆浆机");
  //根据结果进行判断
  if(result !=null) {
   System.out.println(p.getName()+"在"+m.getMarketName()+"买到了"+result.getProName());
  }
  else {
   System.out.println(p.getName()+"白跑一趟，在"+m.getMarketName()+"什么也没买到");

  }
 }

}

结果

3.3构造方法的定义

1.构造方法的定义

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

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

2.构造方法的重载

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

3.4 this关键字

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

3.5 垃圾回收

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

3.6 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关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行由于类只加载一次，因此静态代码块只执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化。

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();
   
  }
}

结果：

3.7成员内部类

成员内部类

在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。根据内部类的位置、修饰符和定义的方式可分为:成员内部类、静态内部类、方法内部类。
在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。在成员内部类中，可以访问外部类的所有成员。
如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象创建内部类对象的具体语法格式如下:

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

3-2银行新用户现金业务办理代码案例：

/*
 * 定义银行类
 * 属性：银行名称，储户名称，密码，余额，交易额度
 * 功能：开门营业，存钱，取钱，关门
 */
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();
  
 }
}

结果：

4.1类的继承

继承的概念

在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物，同理，波斯猫和巴厘猫继承自猫，而沙皮狗和斑点狗继承自狗。这些动物之间会形成一个继承体系，具体如下图所示。

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

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

在Java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。

class A{}

class B{}

class C extends A,B{} //C类不可以同时继承A类和B类

多个类可以继承一个父类，例如下面这种情况是允许的。

class A{}

class B extends A{}

class C extends A{} //类B和类C都可以继承类A

在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。例如下面这种情况是允许的。

class A{}

class B extends A{} //类B继承类A，类B是类A的子类

class C extends B{} //类C继承类B，类C是类B的子类，同时也是类A的子类

重写父类方法

在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中下需要对继承的方法进行一些修改，即对父类的方法进行重写。需要注意的是，在子类中重写的方法需要和父类重写的方法具有相同的方法名、参数列表以及返回值类型。方法重写是对父类功能的一些改进，同时也是对父类功能的扩展，而也是多态的一个非常重要的前提就是方法的重写

案例

子类重写父类要保证子类方法的权限必须大于或者等于父类方法权限，否则将会报错

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类的对象，子类对象
  }
}

结果：

4.2Final关键字

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

final修饰的类不能被继承
final修饰的方法不能被子类重写
final修饰的变量（成员变量和局部变量）是常量，只能赋值一次

4.3抽象类和接口

抽象类

当定义一个类时，常常需要定义一些方法来描述该类的行为特征，但有时这些方法的实现方式时无法确定的。
Java允许在定义方法时不写方法体，即大括号“{}”，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键词来修饰，具体如下：

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

shout()

接口

如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一中方式来定义，即接口。接口是由常量和抽象方法组成的特殊类，时对抽象类的进一步抽象。
在定义接口时，需要使用interface关键词来声明，其语法格式如下：

[public] interface 接口名 [extends 接口1，接口2...]{
[public] [static] [final] 数据类型常量名 = 常量值；

[public] [abstract] 返回值抽象方法名(参数列表)；

}

在上面的语法中，一个接口可以有多个父接口，它们之间用逗号隔开。一个类只能有一个父类，而一个类可以实现多个接口。接口中的变量默认使用“public static final”来修饰，即全局常量；接口定义的方法默认“public abstract”来修饰，即抽象方法。如果接口声明为public，则接口中的变量和方法全部为public。
由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法。此时需要定义一个类，并使用implements关键字实现接口中所有的方法。一个类可以在继承的同时实现多个接口，在implements子句中用逗号隔开。接口的实现类声明格式如下:

[修饰符] class <类名> [extends <超类名>]

[implements <接口1> ,<接口2>,......]

4-1USB接口程序设计代码：

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();
}

结果：

4.4多态

多态概念

1.在设计一个方法时，通常希望该方法具备一定的通用性。多态的前提是要有继承，要有方法的重写。我们可以把它理解为一个事物具备的多种形态，称之为多态。比如说一个人，在不同的时期和不同的环境下它所表现出来的状态，或者形态是不一样的。在同一个方法中，参数类型不同而导致出现的运行结果也不同，那就产生出这种多态的现象。
2.在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类，它是类层次结构的根类，每个类都直接或间接继承自该类，所有对象包括数组都实现了这个类的方法常用方法

在Object类中定义了toString（）方法，在该方法中输出了对象的基本信息，Object类中的toString（）方法中的代码：

getClass().getName()+"@"+Integer.toHexString(ha shCode());

getClass().getName():代表返回对象所属类的类名
ha shCode():代表返回该对象的哈希值
Integer.toHexString(ha shCode()):代表将对象的哈希值用16进制表示
ha shCode()是Objest类中的一个方法

匿名内部类

在编写程序时，在类里面定义的类称之为内部类，内部类是外部类的一个成员，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("货物运输车辆保养完毕!");
 }
 
}

结果：

三月

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第二篇Java核心技术复习

类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。在面向对象的思想中最核心的就是对象，为了在程序中创建对象，首先需要定义一个类。类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，成员方法用于描述对象的行为，可简称为方法。在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。
复制链接

扫一扫