java 抽象类 接口 Object类

抽象类

普通类是一个完善的功能类，可以直接产生对象并调用，其中的方法都已经实现完整

抽象类最大的特点是包含了抽象方法，抽象方法是只声明而未实现（没有方法体的方法），抽象方法定义时要用abstract关键字完成，抽象类关键字要用abstract关键字声明。

抽象类的使用原则：

1.      抽象类必须有子类，用extends继承，一个子类只能继承一个抽象类

2.      子类必须覆写抽象类中的全部抽象方法

3.      抽象类可以使用对象的向上转型方式，通过子类进行实例化操作

4.      将内部类定义为内部抽象类，同时使用static声明，这就表示一个外部类

抽象类的应用:模板设计模式

 

 

接口

接口属于一种特殊的类，如果一个类定义时全部由抽象方法和全局常量组成，那么这种类就称为接口，接口使用interface关键字进行定义的。

 

全局常量就是用public static final定义的

 

接口使用原则：

1.      每一个接口必须定义子类，子类用implements关键字实现接口

2.      接口的子类必须覆写接口中所定义的全部抽象方法

3.      利用接口的子类，采用对象的向上转型方式，进行接口的实例化操作

class 子类 [extends 父类]  [implements 接口1，接口2，……]

 

Ø  每一个子类可以实现多个接口，但是只能继承一个父类（或抽象类）

Ø  如果一个子类既要实现接口又要继承抽象类，则应该采用先继承后实现的方式完成。

Ø  定义接口方法时，就算没有写上public，最终也将是public，即接口中的访问权限只有一种：public

Ø  每一个抽象类都可以实现多个接口，一个接口却不可以继承抽象类，但是一个接口可以同时继承多个接口

接口的实际作用：

ü  工厂设计模式

例：

interface fruit{     //定义接口
	public abstract void eat();
}

class Apple implements fruit{   //实现接口
	public void eat(){
		System.out.println("吃苹果");
	}
}

class Orange implements fruit{   //实现接口
	public void eat(){
		System.out.println("吃橘子");
	}
}

class Factory{     //过渡断
	public static fruit getInstance(String classname){
		if("apple".equals(classname)){
			return new Apple();
		}
		if("orange".equals(classname)){
			return new Orange();
		}
		return null;
	}
}


public class test {
	public static void main(String args[]){
		fruit f=Factory.getInstance("apple");
		f.eat();
	}

}

ü  代理设计模式(proxy)

例:

interface Network{          //定义Network接口
	public void browse();     //定义浏览的抽象方法
}

class Real implements Network{        //真实的上网操作
	public void browse(){             //覆写抽象方法
		System.out.println("上网浏览信息");
	}
}

class Pro_xy implements Network{      //代理上网
	private Network net;              
	public Pro_xy(Network net){        //设置代理的真实操作
		this.net=net;                  //设置代理的子类
	}
	public void check(){              //与具体上网相关的操作
		System.out.println("检查用户信息是否合法");
	}
	public void browse(){
		this.check();                 //可以同时调用多个与具体上网相关的操作
		this.net.browse();            //调用真实的上网操作
	}
}



public class proxy {
	public static void main(String args[]){
		Network net=null;            //定义借口对象
		net=new Pro_xy(new Real());  //实例化代理，同时传入代理的真实操作
		net.browse();                //客户只关心上网浏览功能
	}

}

接口与抽象类：

抽象类一个最大的缺点是一个子类只可以继承一个抽象类，存在单继承局限，所以接口与抽象类都可以使用时,要优先考虑接口。

 

Object类

Object类可以接收所有类的实例化对象，即Object类是所有类的父类

对于任意一个简单的java类而言，理论上应该覆写Object类中的3个方法

ü  取得对象信息：public String toString();

如果一个对象直接输出，那么默认情况下输出的是一个对象的地址。

例：

class Person{
	
}

public class test_demo {
	public static void main(String args[]){
		Person per=new Person();
		System.out.println(per);
		System.out.println(per.toString());
	}

}

所以对象输出默认调用了Object类中的toString()方法，每一个子类也可以根据自己的需要进行覆写。

例：

class Person{
	private String name;
	private int age;
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String toString(){
		return "姓名："+ this.name +"，年龄：" + this.age;
	}
}

public class test_demo {
	public static void main(String args[]){
		Person per=new Person("Anne",19);
		System.out.println(per);
		System.out.println(per.toString());
	}

}

ü  对象比较：equals()

String类也是Object类的子类，所以String类的equals()方法就是覆写了Object类的equals()方法。在Object类中，默认的equals()方法实现比较的是两个对象的内存地址数值。

ü  使用Object接收所有引用数据类型

Object类是可以接收所有引用数据类型的数据，这就包括了数组、接口、类。

 

包装类

在java设计中一直提倡一个原则：一切皆对象。这个原则本身有一个漏洞——基本数据类型不是对象

将基本数据类型作为一个类的属性保存起来，这就相当于把基本数据类型包装了一下。

例：

class Int{
	private int num;
	public Int(int num){
		this.num=num;
	}
	public int IntValue(){
		return this.num;
	}
}

public class test_demo {
	public static void main(String args[]){
		Int temp=new Int(12);
		int result=temp.IntValue();
		System.out.println(result*result);
	}

}

装箱与拆箱

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

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

 

包装类最大的优点在于：将字符串变为指定的基本数据类型

²  Integer类：public static int parseInt(String s);

²  Double类：public static double parseDouble(String s);

²  Boolean类：public static boolean parseBoolean(String s)

 

基本数据类型变为字符串

1.    任何基本数据类型遇到String后都会变为String型数据

2.    利用String类的方法public static String valueOf(数据类型 变量)