标签：抽象   封装   继承   多态   函数   

Java基础——封装、继承、多态

——小实例快速成长

抽象：

1.目的：将复杂的东西简单化，将繁乱的内容有序化。

2.过程：对相同、相似的东西合而为一，对不同的内容进行归门别类。

3.结果：类、接口。

封装：

1.目的：化零为整，将零散的内容进行归属，进行权限控制。

2.过程：将某对象的属性、方法（功能）统一到其名下，并分别设置。适当的权限进行控制管理。

3.结果：对象，接口。

继承：

1.求大同存小异；在一个系列内，大部分都有的内容，就划归父类；子类将父类的内容继承过来，可以有自身的一些发展和个性。

2.增强复用性、可扩展性。

多态：

随机应变，应需而动。

1.运行时多态——程序运行起来后，接口根据当时实情进行智能分配和对接。

2.编译时多态——预先写好，子类在父类基础上的对相同功能的性能改变。

函数（function）：

1.结构：分五个组成部分——权限修饰符、函数名、参数、函数体、返回值类型。（不同情况下，有些内容需要省去）

2.重写：相同函数名及参数的函数体的不同实现。

3.重载：对某一功能的结构级的彻底变革。参数必变、返回值类型或函数体实现可以有变（其中“参数”的个数或参数类型至少有一个发生改变）。

示例代码：

public class TestBase {
	public static void main(String[] args) {
		//Cat cat1 = new Cat();  //提示“实际参数列表和形式参数列表长度不同”的错误
		Cat cat2 = new Cat("波斯");
		Wolf wolf1 = new Wolf();
		wolf1.run("蒙古狼");
		Wolf wolf2 = new Wolf("蒙古狼");
		wolf2.run("蒙古狼");
		Tiger tiger = new Tiger();
		tiger.eat("肉");
		
		Animal animal = new Wolf("西北狼");
		animal.run();
	}
}

//抽象类
abstract class Animal {
	String Food;
	protected String Name;
	
	//无参构造函数
	public Animal(){
		System.out.println("\n——父类 无参构造方法！\n");
	};
	
	//有参构造函数
	public Animal(String name){
		this.Name = name;
		System.out.println(Name + "的 父类 有参构造方法！\n");
	}
	
	//抽象方法
	abstract void eat(String food);
	
	//一般方法
	public void run(){
		System.out.println("父类一般方法run()" + "I like run!\n");
	}
}

//继承 父类Animal
class Cat extends Animal {
	//有参构造函数
	public Cat(String name){
		//初始化父类构造方法
		super(name);
		System.out.println("子类Cat有参构造函数！\n");
	}
	
	public void eat(String food) {
		//成员变量Food继承自父类——protected成员变量
		this.Food = food;
		System.out.println("猫以"+food+"为食！\n");
	}
}

//继承 父类Animal
class Wolf extends Animal {
	//无参构造方法
	public Wolf(){
		//非显示调用父类构造方法，当程序使用本无参构造方法是，系统将自动调用父类无参构造方法
		
		//检验————无参构造函数调用的时机
		System.out.println("调用了Wolf类的无参构造方法！\n");
	};
	
	public Wolf(String name){
		//非显示调用父类构造方法，当程序使用本有参构造方法是，系统将自动调用父类无参构造方法
		
		//成员变量Name继承自父类——public成员变量
		this.Name = name;
		System.out.println("子类Wolf有参构造函数！\n");
	}
	public void eat(String food) {
		//成员变量Food继承自父类——protected成员变量
		this.Food = food;
		System.out.println("狼以"+food+"为食！\n");
	}
	
	//重写 父类的 一般方法
	public void run(){
		System.out.println("子类wolf重写父类的run()方法" + 
					"I don't like run, but I must be to do.\n");
	}
	
	//重载 父类的 一般方法
	public void run(String name){
		System.out.println(name + "子类wolf重载父类的run()方法——" + 
					"name" + "说：\"" + "I don't like run, but I must do.\"\n");
	}
}

//继承 父类Animal
class Tiger extends Animal {
	public void eat(String food) {
		this.Name = "东北虎";
		System.out.println("我的名字叫:" + Name + "； 我以" + food + "为食！\n");
	} 
}

运行效果图：

Java基础——封装、继承、多态

标签：抽象   封装   继承   多态   函数   

原文地址：http://blog.csdn.net/wangqingbo0829/article/details/44837517