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

àì夳堔傛蜴生んèń 2023-06-28 06:05 110阅读 0赞

# 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.....");
    	}
    
    }