JAVA进阶————Java继承，多态，重写，修饰符以及super与this使用，Oject对象

1.面向对象进阶

1.1继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

• 子类继承父类的属性和方法，关键字"extends"

• 子类是对父类的扩展，可增添新的属性和方法

• 子类不能直接访问父类的私有成员变量和方法

• java只支持单继承和多层继承，不支持多重继承

事例：

父类：
public class Person {
    String name;
    int age;
    private  int password;  //私有
    public Person(){
​
    }
    public Person(String name,int age,int password){
        this.name = name;
        this.age = age;
        this.password = password;
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    ..................

子类：
public class Student extends Person{    //继承Person类
    String major;
​
    public Student(){}
    public Student(String name,int age,int password,String major){
        this.name = name;
        this.age = age;
        setPassword(password);//调用父类方法访问私有变量
        this.major = major;
    }

1.2重写

在子类中可以根据需要对从父类中继承来的方法进行改造， 也称为方法的重置、覆盖

override/overwrite。在程序执行时，子类的方法将覆盖父类的方法

• 子类重写的方法与父类：方法名相同，参数列表相同，返回值类型不能大于父类

• 子类不能重写父类private的私有方法

父:
 public void study(){
        System.out.println(this.name+"人在学习");
    }
    
子:
 public void study(){
        System.out.println(this.name+"学员在学习");
    }
 
 结果:
 
  Person f = new Person("老李",47);
    Student s = new Student("小李",22);
    f.study();
    s.study();
    
 运行:
    老李人在学习
    小李学员在学习
 

1.3四种访问权限修饰符

• private 同一个类内部可以访问，私有

• (缺省) default 同一个包可以访问

• protected 同一个包或者不同包的子类

• public 同一个工程

1.4 super关键字

• super可以理解为父类的，super可以用来调用属性、方法、构造器

调用父类构造器:
    public Student(String name,int age){
        super(name,age);
    }
    
 调用父类方法:
    super.getAge();
    
 调用父类属性:
    super.name

与this区别:

super:

作用范围:父类

调用父类构造器时，放在子类构造器首行

 public Student(String name, String name1) {
        super(name);
        this.name = name1;
    }

this:

作用范围:本类，若找不到去其父类寻找

调用本类构造器时，放在造构造器首行

public Person(String name, int age) {
        this(name);
        this.age = age;

1.5多态

1.5.1概念

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

1.5.2多态存在的条件

• 继承

• 重写

• 父类引用，指向子类对象

1.5.实例

父类:
public class Animal {
    public  void  Eat(){
        System.out.println("动物吃饭");
    }
    public  void Shout(){
        System.out.println("动物叫");
    }
}

子类：
1.
public class Dog extends Animal{
    @Override
    public void Eat(){
        System.out.println("狗吃骨头");
    }
    @Override
    public  void Shout(){
        System.out.println("汪汪");
    }
}
​
​
2.
public class Cat extends Animal{
​
    public void Eat(){
        System.out.println("猫吃鱼");
    }
​
    public void Shout(){
        System.out.println("喵喵");
    }
}
​

运行:
 public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        fun(dog);       //指向子类对象
        fun(cat);
    }
    public static void fun(Animal animal){      //父类引用
        animal.Shout();
        animal.Eat();
    }
    
结果：
​
    汪汪
    狗吃骨头
    喵喵
    猫吃鱼
​

1.6 java.lang.Object对象

在Java中，子类只能继承一个父类，如果定义类时没有使用 extends关键字指定继承任何类，那一定是继承java.lang. object

1.6.1equals

1.与==区别

• ==

1. 对于基本数据类型的变量，如：Byte（字节型）、short（短整型）、char（字符型） 、int（整型）、float（单精度型/浮点型）、long（长整型）、double（双精度型） 和boolean(布尔类型）， ==是直接对其值进行比较。

2. 对于引用数据类型的变量，则是对其内存地址的比较

• equals

  在没有重写equals方法之前，equals方法里是直接调用==，实质上与==没有差别。注意：equals方法不能作用于基本数据类型的变量，因为基本数据类型非对象的缘故，没有方法。

在一些类库当中这个方法被重写了，这样就不在是去比较在堆内存中的存放地址了。这里我们可以看下String类里equals方法的重写：

 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
​
        Person person = (Person) o;
​
        return password == person.password;
    }

运行结果:
 f.setPassword(123456);
 System.out.println(f.equals(666666));
 结果:false

1.6.2toString

• 默认情况(未被重写的时候)

  会默认返回:全类名(包名+类名)+@+哈希值的十六进制

  System.out.println(s.toString());
  ​
  f1.demo.Student@0

• 被重写的情况

  在IDEA中重写toString的快捷键是alt+insert -->toString,重写的默认toString方法代码如下

      @Override
      public String toString() {
          return "Person{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  ", password=" + password +
                  '}';
      }

  Person{name='小李', age=22, password=0}

1.7自动装箱和装箱

1.7.1定义

装箱是将值类型装换成引用类型的过程；拆箱就是将引用类型转换成值类型的过程；

包装类和基本数据类型的相互转换，将 int 类型转换为 Integer 类型，将 double 类型转换为 Double 型等等...

1.7.2操作

int temp = 10 ; // 基本数据类型
Integer x = new Integer(temp) ; // 将基本数据类型变为包装类
​
Float f = 10.3f ;   // 自动装箱
float x = f ;       // 自动拆箱