对象和类

一、对象和类的区别

java的类通常通过class关键字进行定义，它代表了一种抽象的集合，例如，学生类，动物类等，在它的里面可以定义各种属性和方法，它们代表了每个类实例的特定的数据和动作。java虚拟机对类只加载一次，对它的静态成员也只加载一次。

对象，指的是某个特定抽象的实例，它属于某一种类型，也就是对象是通过类来创建的。它必须从属于某一个类，通过new关键字进行创建，它代表一个特定类型的实例，对象可以被多次创建。

简而言之，类是一种抽象，而对象是类的实现。

二、继承与重用代码

java采用的是单继承机制，使用extend关键字。通过继承以后，子类就拥有了父类所有成员。从而达到代码重用的目的。在继承过程中，可以通过方法的覆盖来实现多态，让子类拥有自己独特的方法实现方式。

例子：

类如如下：

 

 

class Animal
{
	//呼吸
	void breath()
	{
		System.out.println("Breath.....");
	}
	//叫
	void cry()
	{
		System.out.println("Cry.....");
	}

}
//猫类继承动物类
class Cat extends Animal
{
	//重写cry方法
	void cry()
	{
		System.out.println("喵喵....");
	}
}
//测试类
class  ExtendTest
{
	public static void main(String[] args) 
	{
		//创建动物对象
		Animal animal=new Animal();
		//创建猫对象
		Cat cat=new Cat();
		//调用动物的呼吸方法
		animal.breath();
		//调用动物的叫方法
		animal.cry();
		//调用猫的呼吸方法
		cat.breath();
		//调用猫的叫方法
		cat.cry();
	}
}

 

 

 

运行结果：

 

三、多态

“多态”一词按照字面上的理解就是：“多种形式，多种状态”。它的本质是发送消息给某个对象，让该对象自行决定响应何种行为，通过将子类对象引用赋值给超类对象引用变量实现动态方法调用。

 

例子如下：

 

类图如下：

 

class Man
{
	int eyes=2;
	String getEyesColor()
	{
		return null;//返回眼睛的颜色
	}
}
class AsiaMan extends Man
{
	//重写（覆盖）
	String getEyesColor()
	{
		return "black";//返回黑色
	}
}
class EuroMan extends Man
{
	//重写（覆盖）
	String getEyesColor()
	{
		return "blue";//返回蓝色
	}
}
class  PolymorphismTest
{
	public static void main(String[] args) 
	{
		//创建一个亚洲人，转换成Man类型
		Man asiaMan=new AsiaMan();
		//创建一个欧洲人，转换成Man类型
		Man euroMan=new EuroMan();
		System.out.println("Asia Men eyes' color is "+asiaMan.getEyesColor());
		System.out.println("Euro Men eyes' color is "+euroMan.getEyesColor());
	}
}

 

 

运行结果：

 

 四、静态成员

类的静态成员是通过static关键字修饰成员，主要包括：静态成员变量、静态方法和静态代码块，它们具有以下一些特点：

 

1）在类加载的时候，就进行创建和初始化或执行代码。

 

2）它们对于一个类来说，都只有一份。

 

3）类的所有实例都可以访问到它们

 

例如：

class StaticTest 
{
	//静态成员变量
	static int a=1;
	//静态方法
	static void testMethod()
	{
		System.out.println("test method....");
	}
	//静态代码块
	static
	{
		System.out.println("execute static codes...");
	}
	public static void main(String[] args) 
	{
		System.out.println("a="+a);//打印静态变量的值
		StaticTest.testMethod();//通过类名直接访问
	}
}

 

运行结果：

 

 

 

 

五、派生类的构造方法为父类传递参数

在java中，使用super()为父类的构造方法提供参数，通过参数的数目和类型来决定调用哪个构造方法。如果调用的是父类的默认的无参数构造方法，则可以不必显示地使用super()

 

例如：

 

//父类
class Base
{
	//成员变量a
	int a;
	//有参数的构造方法
	Base(int a)
	{
		this.a=a;
	}
}
//儿子
class Child extends Base
{
	//无参数的构造方法
	Child()
	{
		//为父类传入一个100的参数
		super(100);
	}
	//有参数的构造方法
	Child(int a)
	{
		//为父类传入一个a参数
		super(a);
	}
}

/**
*new Child();==>无参数构造方法
*new Child(100);==>有参数构造方法
*/

 

 

六、接口和抽象类的区别

抽象类是一种功能不全的类，接口只是一个抽象方法声明和静态不能被修改的数据的集合，两者都不能被实例化。从某种意义上说，接口是一种特殊形式的抽象类，在java语言中，抽象类表示一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

 

例如：

类图：

 

abstract class Fruit//水果
{
	double weight;//重量
	double volume;//体积
	abstract String getTaste();//味道
}
//可包装接口
interface Packable
{
	void pack();
}
//可分瓣接口
interface Divisible
{
	void divisible();
}
class Apple extends Fruit implements Packable
{
	String getTaste()
	{
		return "甜";
	}
	public void pack()
	{
		System.out.println("包装苹果...");
	}
}
class Orange extends Fruit implements Packable,Divisible
{
	String getTaste()
	{
		return "酸";
	}
	public void pack()
	{
		System.out.println("包装橙子...");
	}
	public void divisible()
	{
		System.out.println("把橙子分瓣...");
	}
}
class  AbstractInterfaceTest
{
	public static void main(String[] args) 
	{
		Apple apple=new Apple();
		System.out.println("apple taste "+apple.getTaste());
		apple.pack();
		Orange orange=new Orange();
		System.out.println("==========================");
		System.out.println("orange taste "+orange.getTaste());
		orange.pack();
		orange.divisible();

	}
}

 

执行结果：

 

 

 

 每天一点点希望对大家有利~