面向对象高级续2(instanceof关键字、抽象类和接口的应用、Object类、包装类)

 

具体内容

在java中可以使用instanceof关键字判断一个对象到底是哪个类的实例。

·对象 instanceof 类   - ->返回boolean类型；代码如下：

class A{					// 定义类A
	public void fun1(){		// 定义fun1()方法
		System.out.println("A --> public void fun1(){}") ;
	}
};
class B extends A{
	public void fun1(){		// 此方法被子类覆写了
		System.out.println("B --> public void fun1(){}") ;
	}
};
public class PolDemo05{
	public static void main(String args[]){
		A a1=new B();
		System.out.println("a1实例是否属于类A："+(a1 instanceof A));
		System.out.println("a1实例是否属于类B："+(a1 instanceof B));
		//程序输出
		//a1实例是否属于类A：true
		//a1实例是否属于类B：true
	}
	
};

在开发中应记住以下规则：

一个类永远不要去继承一个已经实现好的类，而只能继承抽象类或者是实现接口。

抽象类和接口的应用

抽象类简单示例

abstract class A	//定义抽象类A
{
	public abstract void fun();		//定义抽象方法
}
class B extends A	//类B继承自抽象类A
{
	public void fun(){	//覆写抽象类中方法
		System.out.println("hello world");
	} 
}
public class abstractCaseDemo01
{
	public static void main(String args[]){
		A a=new B();	//通过实现的子类为抽象类实例化
		a.fun();	//最终调用子类中的方法
	}
}

接口的简单示例

interface A	//定义接口A
{
	public abstract void fun();	//抽象方法
}
class B implements A	//类B实现接口A
{
	public void fun(){	//覆写接口中所有的抽象方法
		System.out.println("hello world");
	} 
}
public class interfaceCaseDemo01
{
	public static void main(String args[]){
		A a=new B();	//通过实现的子类对接口进行实例化
		a.fun();	//调用实现类中的方法
	}
}

接口的简单应用

interface USB	//定义接口A
{
	public abstract void start();	//抽象方法
	public abstract void stop();	//抽象方法
}
class Computer	//电脑类
{
	public static void plugin(USB usb){	//要想使USB设备工作，则必须插入电脑
		System.out.println("-------USB开始工作---------");
		usb.start();
		usb.stop();
	}
}
class Flash implements USB	//U盘实现USB接口
{
	//覆写接口中所有的抽象方法
	public void start(){	
		System.out.println("U盘开始工作");
	} 
	public void stop(){
		System.out.println("U盘停止工作");	
	}
}
class Print implements USB	//打印机实现USB接口
{
	//覆写接口中所有的抽象方法
	public void start(){	
		System.out.println("打印机开始工作");
	} 
	public void stop(){
		System.out.println("打印机停止工作");	
	}
}
public class interfaceCaseDemo02
{
	public static void main(String args[]){
		Computer.plugin(new Flash());	//将U盘插入电脑
		Computer.plugin(new Print());	//将打印机插入电脑
	}
}

工厂设计模式

工厂设计模式简单描述：

当客户端需要一个实例时，不需要自己创建，只需从工厂里面直接取已经new好的对象就可以了，只需告知需要的是哪个类的实例。代码解释：

interface Fruit
{
	public void eat();	//拿到水果就是吃
}
class Apple implements Fruit	//定义苹果类实现水果接口
{
	public void eat(){
		System.out.println("吃苹果");
	}
}
class Orange implements Fruit	//定义苹果类实现水果接口
{
	public void eat(){
		System.out.println("吃橘子");
	}
}
class Icebox	//定义冰箱类，里面放的都是水果 即工厂
{
	public static Fruit getFruit (String className) throws Exception{
		return (Fruit)Class.forName(className).newInstance();
	}
}
public class interfaceCaseDemo03
{
	public static void main(String args[]){
		try{
			Fruit fruit=Icebox.getFruit("Apple");	//想要得到水果，只需要从冰箱里拿即可
			fruit.eat();
		}catch(Exception e){
			System.out.println("对不起，冰箱里没有该水果！去买吧---");
		}
		
	}
}

Object类

具体内容

在java中所有的类都有一个公共的父类就是object类，一个类只要没有明显的继承的一个类，则肯定是object类的子类。如以下代码两种格式所表示的含义是一样的：

·class Person{};

·class Person extends Object{}；

一个完整的类是要覆写object类中三个方法的，对象比较：public boolean equals(Object obj)、取得Hash码：public int hashCode()、对象打印时调用：public String toString()。

toString方法

当一个对象被打印的时候默认会调用roStirng()方法，此时如果在类中覆写了roString方法，则肯定会调用覆写过的方法。代码如下：

class Person
{
	private String name;
	private int age;
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String toString(){
		return "姓名是："+name+"年龄是："+age;
	}
}
public class ObjectDemo01
{
	public static void main(String args[]){
		Person per=new Person("张三",20);
		System.out.println("没有toString方法"+per);
		System.out.println("有toString方法"+per.toString());
		//程序输出：
		//没有toString方法姓名是：张三年龄是：20
		//有toString方法姓名是：张三年龄是：20
	}	
}

equals方法

equals方法的主要功能是完成两个对象的比较操作。

String本身也是Object的子类，所以已经覆写了此方法

class Person
{
	private String name;
	private int age;
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String toString(){
		return "姓名是："+name+"年龄是："+age;
	}
}
public class ObjectDemo01
{
	public static void main(String args[]){
		Person per=new Person("张三",20);
		System.out.println("没有toString方法"+per);
		System.out.println("有toString方法"+per.toString());
		//程序输出：
		//没有toString方法姓名是：张三年龄是：20
		//有toString方法姓名是：张三年龄是：20
	}	
}

Object类是所有类的父类，则所有的对象都可以使用object进行接收，但是object不只是能够接收对象，它可以接收任意的引用数据类型。

使用object接收接口实例：

interface A	//定义A接口
{
	public String getInfo();
}
class B implements A
{
	public String getInfo(){	//覆写方法
		return "hello world";
	}
}
public class ObjectDemo04
{
	public static void main(String args[]){
	A a=new B();	//向上转型，为接口实例化
	Object o=a;		//使用object接收，向上转型
	A x=(A)o;		//向下转型
	System.out.println(x.getInfo());
}
}

数组也可以使用Object类接收：

public class ObjectDemo02
{
	public static void main(String args[]){
		int temp[]={1,3,5,7,9};	//定义整形数组
		print(temp);	//调用静态方法
	}	
	public static void print(Object obj){
		int x[]=(int[])obj;		//将object类转为数组，向下转型
		for(int y:x){
			System.out.print(y+"、");
		}
	}
}

包装类

概念

从数据的划分我们知道java中的数据类型分为基本数据类型和引用数据类型，很明显基本数据类型是不能称为对象的。此时，就需要将基本数据类型进行包装，将八种数据类型变为一个类的形式，这就是包装类的作用。

这八种包装类，所继承的父类不全部相同。其中Boolean、Character父类为Object，Integer、Short、Long、Float、Double、Byte父类为Number

Number类的定义

Number类是一个抽象类，主要是将数字包装类中的内容变为基本数据类型，主要操作方法如下：

由上可知：Number 的子类必须提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法。

下面以Integer和Float为例

装箱及拆箱：

·装箱：将基本数据类型变为包装类称为装箱。

·拆箱：将包装类变为基本数据类型称为拆箱。

代码示例：

public class wrapperDemo01
{
	public static void main(String args[]){
		int a=3;	//基本数据类型
		Integer b=new Integer(a);	//装箱：将基本数据类型变为包装类
		float c=2.2f;
		Float d=new Float(c);
	}
}

在JDK1.5之前对于程序本身来说是不能直接进行加、减、乘、除的操作的，但是在1.5以后对包装类进行了改变，增加了自动装箱和自动拆箱的功能，而且可以用包装类进行数字运算。代码示例：

public class wrapperDemo02
{
	public static void main(String args[]){
		Integer a=3;	//自动装箱 将基本数据类型变为包装类
		Float f=3.3f;	
		System.out.println(a+f);
		//程序输出：2.3
	}
}

包装类的应用

包装类在实际应用的最多的是在字符串变为基本数据类型的操作上，例如：将一个全由数字组成的字符串变为int或float类型的数据，在包装类Integer和Float中分别提供了以下方法：

·A、Integer类(字符串转int型)

public static int parseInt(String s) throws NumberFormatException

·B、Float类(字符串转float型)

public static float parseFloat(String s) throws NumberFormatException

具体应用：

public class wrapperDemo03
{
	public static void main(String args[]){
		String str1="123";	//声明一个由数字组成的字符串
		Integer a=Integer.parseInt(str1);	//使用Integer包装类提供的静态方法进行转换
		System.out.println(a);
		String str2="12";
		Float f=Float.parseFloat(str2);
		System.out.println(f);
	}
}

匿名内部类

内部类：在一个类的内部还有另外的一个类称为内部类。匿名内部类：如果一个类在整个操作中只使用一次的话，就可以将其定义成匿名内部类，匿名内部类是在抽象类及接口的基础上发展起来的

interface A
{
	public void printInfo();
}
class X
{
	public void fun1(){
		this.fun2(new A(){
			public void printInfo(){
				System.out.println("hello world");
			}
		});
	}
	public void fun2(A a){
		a.printInfo();
	}
		
}
public class NoInnerClassDemo
{
	public static void main(String args[]){
		new X().fun1();	//实例化X类的对象，并调用fun1()方法
	}
}