java基础（6Day-继承-多态）

Java类和对象-继承-多态

所谓继承，就是往上找。

（先找自身，如果没有，找父类，没有，再向上找，直到Object结束）

继承 - 创建子类，父类构造方法会执行吗？

public static void main(String[] args) {
		Person p = new Person();
		p.setName("李世民");
		p.setAge(49);
		System.out.println("李世民 Person对象:"+p.toString());
		
		Student s = new Student();
		s.setName("学生 李治");
		s.setAge(20);
		System.out.println("学生 李治 Student对象："+s.toString());

	}

运行结果：

结论：
不仅父类的构造方法会执行
父类先于子类构造方法执行（没有父类就没有子类）
创建了一个学生，其实是创建了两个对象：一个Person对象，一个Student自身的对象

Object这个类

1.toString()  输出对象信息
2.equals()    比较对象是不是相同   对象a.equals(对象b)  
3.hashCode()  哈希值，每个对象的哈希值是唯一的

toString( )找父类（Object.class）

方法重写@Override

方法重写不能改变父类方法的：
	1.参数的个数和类型（参数变量名称可改）
	2.返回值类型不能改。
@Override 注解 保证你重写了父类的方法

方法重载（@Overload）

// 1.方法名称相同，返回值类型相同
// 2.参数类型不同，或个数不同，满足其一就是重载
System.out.println( (int)a );
System.out.println( (double)a );
System.out.println( (int)a+" "(double)b  );

equals

Person p1 = new Person();
Person p2 = new Person();
//equals()来着Object
System.out.println(p1.equals(p2));// 结果为：false
//Object equals 比较的是对象的地址

字符串的 equals( ) 比较的不是 “ 地址 ” 而是 值

String s1=new String("Hello");
String s2=new String("Hello");
System.out.println(s1.equals(s2));// 结果为：ture
System.out.println(s1==s2);// 结果为：fales

String s3="Hello";
String s4="Hello";
System.out.println(s1==s3);// 结果为：fales
System.out.println(s3==s4);// 结果为：ture

向上转型

// 向上转型就是：用父类声明的变量 指向 子类的实例
Object animal = new Animal();
// 父类声明变量指向子类实例
List<String> list=new ArrayList<>();
List<String> list=new ArrayList<>();

参数传递过程中，往往出现向上转型

向下转型

先有向上转型，才能向下转型。
向下转型要强转

谁使用，this就指向谁

public class Person {
	private String name;
	private int age;
	@Override
	public boolean equals(Object obj) {
		Person person=(Person) obj;
		if (this.name.equals(person.name)&&this.age==person.age) {
			return true;
		}else {
			return false;
		}
	}
}

public class DemoEquals {
	public static void main(String[] args) {
        // 构造方法会帮助成员变量的初始化值
        // 基本数据类型 以0为主
        // 对象 字符串 就是null
		Person p1 = new Person();
		p1.setName("chen");
		p1.setAge(20);
		
		Person p2 = new Person();
		p2.setName("chen");
		p2.setAge(20);
		
		boolean b=p1.equals(p2);
		System.out.println(b);
	}
}

多态

问题

总结

对象三大特性-封装

1.成员变量私有化 private
    只能在本类下访问
2.因为成员变量私有化 getter/setter
3.为了初始化一些变量，写构造方法，先写无参构造，否则继承会出问题
	一旦有子类时，创建子类对象，先调用父类构造方法（无参）
4.重写 Object 的 toString 方法

难点1：this，谁调用方法，this就指向谁（括构造方法）
难点2：把 类 当成数据类型来使用
    int n = 3;
	Student s = new Student("程咬金",20);
	3是整数
	程咬金是学生

对象三大特性-继承

继承不是把 父类 的成员变量和方法复制一份到 子类
而是利用 super 变量，往上找，自身的方法没有就找父类对象的方法，一直找到Object
	验证：创建子类对象，先创建父类对象

对象三大特性-多态

多态的前提条件：
    1.要有继承（要有父类和子类）才能形成多态
    2.重写父类的方法
    3.向上转型（父类声明的变量指向子类实例）
到底它调用父类子类方法：
    先看new出来的对象是谁？先找new出来的对象的方法。
    调用方法的参数传递，也会向上转型。

向上转型，向下转型

向下转型，前提是先向上转型，然后才能向下转型

案例

public class Person {
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public boolean equals(Object obj) {
		Person person=(Person) obj;
		if (this.name.equals(person.name)&&this.age==person.age) {
			return true;
		}else {
			return false;
		}
	}
}

public class DemoEquals {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setName("chen");
		p1.setAge(20);
		
		Person p2 = new Person();
		p2.setName("chen");
		p2.setAge(20);
		
		boolean b=p1.equals(p2);
		System.out.println(b);

		p2.setAge(18);
		b=p1.equals(p2);
		System.out.println(b);
	}
}
运行结果：
    true
    false