java--面向对象之继承,多态,抽象

java:面向对象之继承,多态,抽象

一:继承

	继承就是子类继承父类,父类中的属性和方法,子类中就会有,而且子类还可以有自己的单独属性和方法
		如果父类的属性都是private修饰的,子类不能通过 对象.成员名 这种方式访问父类的属性

	用继承一般都是两个类之间有所属关系,不是所有的类之间都随便用继承:如student类可以继承Person类,
		Teacher类也可以继承Person类

注意:一个类只能直接继承一个主类,但是可以间接继承多个别的类如Person类继承Animal类,Student类继承Person类等.

继承中super一般指两个方面一个是值父类的对象,另一个指父类的构造函数(带有参数的或者不带参数的)

package com.hpe.test061;

//继承
public class Person {
	private String name;
	private String sex;
	private int age;
	private String addr;
	
	
	//默认的无参的构造方法
	public Person() {
		
	}
	
	//带有参数的构造方法
	public Person(String name, String sex, int age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	
	//工作
	public void work() {
		System.out.println("工作......");
	}
	
	
	//吃饭
	public void eat() {
		System.out.println("吃饭......");
	}
	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public String getSex() {
		return sex;
	}


	public void setSex(String sex) {
		this.sex = sex;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}


	public String getAddr() {
		return addr;
	}


	public void setAddr(String addr) {
		this.addr = addr;
	}


	@Override
	public String toString() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + ", addr=" + addr + "]";
	}
	
	
}

以上是定义了一个Person的父类,下面再定义一个子类Teacher

package com.hpe.test061;

//子类---派生类
public class Teacher extends Person {
	
	//无参的构造方法
	public Teacher() {
		
	}
	
	
	//构造方法
	public Teacher(String name, String sex, int age, String addr) {
		//这里同样需要设置每一个属性的值,但是父类中已经有一个三个参数的构造方法了,都是一样的代码
		//所以这里可以直接调用父类中的构造方法
		//下面的super代表父类的构造方法
		super(name, sex, age);
		//再单独设置一个addr的属性的设置就行
		this.setAddr(addr);
	}
	
	//生活
	public void life() {
		//下面的super代表父类对象,可以直接用父类中有的方法
		//super代表父类对象
		super.eat();
		super.work();
		
	}

}

可以在main函数中通过Teacher来调用父类的方法

package com.hpe.test061;


public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p1 = new Person();
		p1.work();
		p1.eat();
		
	//如果创建了有参的构造方法,那么无参的构造方法会被覆盖,如果希望使用无参的构造方法,
	//那么需要显示定义无参的构造方法(Teacher类中写上无参的构造方法)
		Teacher t1 = new Teacher();
		t1.work();
		t1.eat();
		System.out.println("-------------");
		t1.life();

	}

}

二:多态—事务的多种

	1)重载和重写
			---重载:在同一个类中,方法名一样,参数列表不一样
			---重写:一定是存在子类和父类的关系中的,返回值类型,方法名字,参数列表都一样,父类中有的方法,子类用一样
							的方法名字和参数列表,只是方法体中的代码可以根据需求不同,写和父类不一样的.
		2)多态在子类对象中的表现形式----->子类对象赋给父类的引用如下例代码

package com.hpe.test063;

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//子类对象的多态性--->子类对象赋值给父类引用-->父类引用指向子类对象
		//Person类是父类,Student是子类,继承了Person类
		Person student = new Student();  /
		
		//多态性在子类对象的多态性中的如何体现
			//编译时看赋值时等号左边-->student是person类的,虽然实际上是一个student,
					//但是只能调用person类中定义的方法
		//运行时看赋值时等号右边--->当子类父类都有work方法时
						//student.work()打印的结果是student类中的work方法
		student.work();
		
		//向下转型 将student这个对象转成Student类型的对象
		Student student2 = (Student)student;
		student2.playGame();
		
		Teacher t2 = new Teacher();
		test(t2);
		

	}

三:抽象类—抽象方法

抽象方法的定义 abstract void 方法名();

抽象方法以abstract修饰,没有方法体,以分号结尾

1)抽象方法:就是得有一个方法,但是里面的具体内容是不具体的.
		比如一个Person类有一个方法是Work,打印工作
			Studnet类继承person类,学生的work方法是打印学习
			Teacher类继承Person类,老师的work方法是打印教学
		两者子类都重写了Work这个方法,所以Person里面的work方法就不是那么具体,但是得有一个Work方法
		所以就把Person中的work方法定义成抽象的方法,用修饰符abstract修饰

2)抽象类:只要这个类中有一个方法是抽象的方法,这个类就是抽象的类,必须用abstract修饰这个了类

3)抽象类只能被继承,不能通过new 类名()这种方式创造对象

4)继承抽象类的那个子类必须把抽象类中所有的抽象方法都重写一遍
5)如果继承抽象类的这个子类没有重写抽象类中的抽象方法,那么这个子类也得是定义成抽象的

以下是一个抽象的父类,有一个抽象的方法work

package com.hpe.test064;

public abstract class Person {
//	public void work() {
//		System.out.println("work.....");
//	}
	
	abstract void work();
}

下面分别学生和教师继承父类的两个子类,已经重写了父类中的抽象方法

package com.hpe.test064;

public class Student extends Person {
	public void work() {
		System.out.println("study.....");
	}
}

package com.hpe.test064;

public abstract class Teacher extends Person{
	public void work() {
		System.out.println("teach.....");
	}

}