【Java面向对象部分 - 3】

【Java面向对象部分 - 3】 1.继承 1.1继承的概念

继承：在Java中，继承是描述类与类之间的关系。(父子)

特点：1.子类可以访问父类中所有非私有的成员，父类不可以访问子类成员。（子类可以找父类，父类不能找子类）
	 2.子类要加载，要先加载父类。（先有的爹后有的儿子）
	 3.单一继承，多层继承。（一个儿子只有一个亲爹，但是爹还有爹）
	 4.子类知道自己的父类是谁，但是父类不知道子类。（从继承格式体现）
	 
注意：Java中任何一个类如果在没有继承的情况下，都是默认继承于Object类
		Object是：基类，超类，根类。（炎黄）
         Java中所有类都是直接或者间接继承于Object类

1.2继承的格式

extends:生产 ---> 继承

子类的定义格式：（继承的声明在子类上，子类知道自己父类是谁）
	public class 子类名 extends 父类名{
	
	}

父类的定义格式：（父类不知道，哪些子类继承了它）  --->段正淳
	public class 父类名称{  

	}

学习技巧：从子类出发，将子类中的共性成员进行向上抽取，再利用继承关系来访问这些成员。

1.3继承关系下成员的访问特点：

在继承关系前提下，访问子类成员：
1.当子类有该成员，则优先访问子类成员，子类没有找父类要，如果所有的父类都没有，那就报错！！

总结：优先级：子类 > 父类

1.4 继承关系下构造方法的访问特点

1.当调用子类构造方法时，当方法中没有申明调用父类构造方法时，系统会默认在子类构造方法的第一行提供一个super();
2.当子类中调用了父类的构造方法时，系统就不提供super();
3.super：本类父类对象的引用。   （亲子鉴定）
public class Die {
     int age;
     String name;

    public Die() {
        System.out.println("父类无参构造");
    }

    public Die(int age, String name) {
        this.age = age;
        this.name = name;
        System.out.println("父类有参构造");
    }
}

class Zai extends Die{
    int age;
    String name;


    public Zai() {
        super();//在子类的构造方法中如果没有任何调用父类构造方法的语句，就会在子类构造方法的第一行默认super();
        System.out.println("子类无参构造");
    }

    public Zai(int age, String name) {                    // this口诀：哪一个对象调用了this所在的方法，this就代表那一个对象
        //super();    super:本类对象的父引用        亲自鉴定    super口诀：哪一个对象调用了super所在的方法，super就代表那一个对象的父对象
        //super(age,name);
        this.age = age;
        this.name = name;
        System.out.println("子类有参构造");
    }
}
class Test2{
    public static void main(String[] args) {
        Zai zai = new Zai();
        Zai zai2 = new Zai(35,"段正淳");
    }
}

1.Zai zai : 先找到Zai类，发现Zai继承了Die，所以先加载Die类，再加载Zai类（只有类加载后才能创建对象）

2.new Zai（）：先找到Zai类无参构造方法执行。

                       因为Zai类的无参构造方法中没有任何调用父类构造方法的语句，所以在第一行会默认有super()；

1.5方法重写：

方法重载：overload
	在同一个类中，方法名相同，形式参数列表不同（个数，类型，顺序不同），与返回值无关。
方法重写：override  
	   1.类与类之间要有继承或者实现关系.
       2.子类和父类中方法的申明完全一致
      	 	2.1权限修饰符：public > protected > default(不写) > private
    		2.2子类中重写的方法的权限修饰符  >=  父类中该方法的权限修饰符
    		2.3父类中被重写的方法的权限修饰符不能是privater
    @Override:如果一个方法上加了这个注解，说明这个方法是重写的方法。
    作用：限定子类重写的方法和父类中被重写的方法格式完全一致
      
       public void eat(){
        System.out.println("抽烟，喝酒");
  	  }
  	  
  	 @Override
     public void eat(){
        System.out.println("喝牛奶");
     } 	    	 

1.6super和this关键字

super:本类父类对象的引用 -- 哪个对象调用了super所在的方法super就是哪个对象的父类对象的引用.  (亲子鉴定)
this:本类对象的引用.  -- 哪个对象调用了this所在的方法,this就是哪个对象.                     (照镜子)

注意：1.super和this不是真实的对象，只是对象的引用。
	 2.super和this只存在与事物描述类中。
	 3.super和this不能存在于static修饰的方法中.

总结：哪个对象调用了this所在的方法，this就代表哪个对象
     哪个对象调用了super所在的方法，super就代表哪个对象的父对象

this.变量名：强制指向本类成员变量
this.方法名：强制指向本类成员方法
this():      本类无参构造
this(实际参数)：本类有参构造

super.变量名：强制指向父类成员变量.
super.方法名：强制指向父类成员方法.
super():     本类父类对象的无参构造
super(实际参数)：本类父类对象的有参构造


变量优先级：  局部变量  > 本类成员变量  >   父类成员变量

2.final关键字

final :最终的,  没有后代的 , 被阉割的.
    类:有子类继承该类,代表有后代  -->  被final修饰的类不能被继承.
    方法:该方法被重写,代表有后代  -->  被final修饰的方法不能被重写
    变量:该变量可以被重新赋值,代表有后代  --> 被final修饰的变量是自定义常量,其值无法被改变

Arrays工具类：

工具类的特点:
	1.工具类中会提供一个私有的无参构造方法,目的是不能去创建工具类对象.
    2.工具类中的成员方法都是静态的,可以使用类名直接调用.
        例如:Arrays.toString() ,  Arrays.sort()

3.Object类

Object是所有类的根类     --->(炎黄)
    当一个类没有写任何继承关系时，默认继承Object类

3.1.getclass()方法： 类的字节码对象

		Object obj = new Object();
        Class clazz= obj.getClass();
        System.out.println(clazz);//java.lang.Object    包名+类名

3.2 toString()方法：

package com.powernode.bean.demo2;

import com.powernode.bean.demo1.Student;

public class ObjectDemo1 {
    public static void main(String[] args) {

        Object obj = new Object();
        Class clazz = obj.getClass();
        System.out.println(clazz);//java.lang.Object    包名+类名

        Student stu = new Student();
        Class aClass = stu.getClass();
        System.out.println(aClass);//class com.powernode.bean.demo1.Student  包名+类名  == 全类名
        System.out.println(stu.hashCode());//1163157884   stu对象在堆内存中的十进制地址
        System.out.println(stu.toString());//com.powernode.bean.demo1.Student@4554617c


    }
}

3.3equals()

public class ObjectDemo3 {
    public static void main(String[] args) {
       

       

        
        Student stu1 = new Student("暴强","河北");
        Student stu2 = new Student("暴强","河北");
        System.out.println(stu1.equals(stu2));
    }
}
class Student extends Object{
    String name;
    String address;
    public Student(String name,String address) {
        this.name = name;
        this.address = address;
    }

    @Override
    public boolean equals(Object obj ) {   //stu2
        Student stu = (Student) obj;   //stu = stu2
        return this.name.equals(stu.name) && this.address.equals(stu.address);  //this = stu1
    }
}

3.4 hashCode()

 System.out.println(stu.hashCode());//1163157884   stu对象在堆内存中的十进制地址

3.5 定义事物描述类：

1.成员变量
2.构造方法
3.setter()  and  getter()
4.成员方法
5.重写toString()    --->打印对象的内容
6.重写hashCode()    --->能够判断两个对象地址和内容是否都相同
7.重写equals()

package com.powernode.test;

import java.util.Objects;

public class Demo1 {


}

class Teacher{
    //1.成员变量
    private String name;
    private int age;

    //2.构造方法
    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //3.setter()   and getter()
    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;
    }

    //4.重写equals() 和 hashCode()
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Teacher teacher = (Teacher) o;
        return age == teacher.age &&
                Objects.equals(name, teacher.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    //5.重写toString()
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    //6. 成员方法
    public void sleep(){
        System.out.println("睡觉");
    }
}

4.脑图