OOP-Inheritance

目录

子类继承父类时将继承子类中所有属性和行为。

Override 复写--重复的定义，重复的写（在子类中重新定义了某一个方法的方法体）

Object class:equals (Object obj)   toString()

父类和子类的构造函数虽不能继承，但是存在关系

“super”:super() in a constructor and super. in a method

---

一旦一个类继承了另外一个类，例如Student 继承 Human 类，

Student叫做子类， subclass

Human 叫做父类，superclass

子类继承父类时将继承子类中所有属性和行为

但是不能继承其中的构造函数。

Student Mike= new Student();
		Mike.sayHi();

class Student extends Human{

}

在代码的编写中，就会有很多的类，就会把那些越不好定义的，ingernal，越笼统的东西放在父类中；当有具体的内容和要求的时候，就会把内容放在子类中。

所以父类和子类中，哪种内容会更多些?------子类，会多出子类特有的内容

class Student extends Human{

//子类中新增的属性
	String school;
	int studentID;
//新增的行为
    public void takeExam(){
		
	}
}

现在子类就拥有了父类的属性，和在本类中再添加的属性

如何区分子类方法中的重名的三种变量

局部变量：直接写成员变量名

本类的成员变量：this.成员变量名

父类的成员变量： super.成员变量名

Override 复写--方法的覆盖：保证父子类之间的方法名称相同，参数列表也相同

区分overload重载：方法名一样，参数列表不一样

@Override 写在方法前面，用来检测是不是有效的正确覆盖重写。（可写可不写）

class Student extends Human{
	String school;
	int studentID;
	
	public void takeExam(){
		
	}
	//override
	void sayHi(){
		System.out.println("hi,everyone!");
		//System.out.println("My ID is :" +studentID);
	}
}

Object class:equals (Object obj)   、 toString()

Object 类是Java中的原生类，我们自己写的所定义的所有的类，都默认继承Object类，即他是所有类的公共最高父类（祖宗类）

在  Test.java  中，

		System.out.println(zhangsan.toString());
		System.out.println(lisi.toString());
		System.out.println(zhangsan.equals(lisi));
		

 这两个字符串，表示的是zhangsan 和 lisi  这两个引用所   保存对象的内存地址。

类+对应的对象存放的地方

equals 指的是 两个对象是不是指向了同一块内存（或者可以理解为，toString方法中的两个字符串是不是一样）

所以添加一行代码

class Test{
	public static void main(String args[]){ 
	
		Human zhangsan=new Human("zhangsan",18,180.0,140.0);
		Human lisi=new Human("ls",18,180.0,140.0);
		
		lisi=zhangsan;
		
		System.out.println(zhangsan.toString());
		System.out.println(lisi.toString());
		System.out.println(zhangsan.equals(lisi));
		
	}
}

以上，toString 返回内存的地址；

一个Object.equals(obj),判断两个reference是否指向了同一个对象。

所以拿到了这个内存地址有什么用么？--没有用，所以一般会把两个方法进行override。

class Human{
	//instance variable 
	 String name;
	int age;
	private double height;
	private double weight;
	String gender;
	
	//constructor
	
	public Human(){
		
		
	}
	public Human(String name ,int age , double height,double weight){
		
		//this.+(instance variable)，no this. is constructor
		this.name=name;
		this.age=age;
		this.height=height;
		this.weight=weight;	
	}
	public Human(String name ,int age , double height,double weight,String gender){
		
		this(name,age,height,weight);
		this.gender=gender;	
	}
	
	//instance method includes
	//return, method name, parameters
	int doAddition(int a,int b){
		int result=a+b;
		return result;
	}

	int doAddition(int a,int b,int c){
		return this.doAddition(a,b)+c;
	}
	
	double doAddition(double a ,double b){
		return a+b;
	}
	
	void sayHi(){
		System.out.println("Hi everyone!");
	}
	double getFactorial(int a){
		double result=1.0;
		for(int i=1;i<=a;i++){
			result=result*i;
		}
		return result;
	}
	
	//setter or modifier
	public void setAge(int age){
		this.age=age;
	}
	//getter or accessor
	public int getAge(){
		return age;
	}
	

-----------------------------------------
	
	//height若是一个私有变量，则需要用getter
	public double getHeight(){
		return height;
	}
	
	//override
	public String toString(){
		return "name is :"+name+"age is:" +age; 
	}
	
	//Object.name 涉及到一个向上转型的知识，后期再讲
	public boolean equals(Human a){
		//要判断，当前的height和参数里的height是否一致
		//this 表示谁的，这里就指的是zhangsan
//a.getHeight()调用的是（）括号中李四的构造函数
		return a.getHeight()==this.getHeight();
	}
	
}

同样再client 端进行声明时，可以稍作修改一下内容，

class Test{
	public static void main(String args[]){ 
	
		Human zhangsan=new Human("zhangsan",18,180.0,140.0);
		Human lisi=new Human("ls",19,190.0,140.0);
		
		System.out.println(zhangsan.toString());
		System.out.println(lisi.toString());
		System.out.println(zhangsan.equals(lisi));
		
	}
}

所以，通过复写，这两个Object 类就有的子类，达到自己想要输出对应东西的效果。

父类和子类的构造函数虽不能继承，但是存在关系

一个类中会有三个东西：attributes，behavior ，constructor

在Human 父类中的默认构造器中，加上这么依据输出用来显示构造器的使用

public Human(){
//用来测试
		System.out.println("***************");
		
	}

“super”:super() in a constructor and super. in a method

在Student 子类中，的constructor，  默认会有super(),这样一句话，用来调用父类中没有参数的构造函数

public Student(){
	
//子类中，默认会有super(),这样一句话，用来//用来调用父类中没有参数的构造函数
        super();
	}

但是，当把父类的defualt构造器给删除了， 就会报错，

 因为父类中的构造函数，在没有被其他构造函数声明时，是默认存在的；当有其他的构造函数存在时，这个默认的，不带参数的构造函数就需要被写出来。

 语法要求：子类构造函数，必须要调用父类的构造函数

构造函数除了生成对象外，还有传递参数来给属性附上一些初始值。

当在子类的构造函数中，将父类的参数进行引用，如果在父类中时有private属性，就会报错

 所以这个时候，用super(),就是调用父类中含有五个私有变量的参数，

//在Student.java中 
public Student(String name ,int age , double height,double 
	weight,String gender,String school,int studentID){
		super(name,age,height,weight,gender);
		this.school=school;
		this.studentId=studentId;
	} 

如果把  super   放在this之后，就会报错

 this代表本类的（我的），super代表父类的，都需要放在第一行。

私有的属性，也是通过super（对应的参数），来进行赋值。

super的第二个用法，用来调用父类中需要重复执行的方法体中的语句

（在子类中）

void sayHi(){
		//其中的super 可以翻译为，我的父亲的
		super.sayHi();
		System.out.println("Hi ,Nice to meet you!");
		
	}