具体内容
在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()方法
}
}