Java重载和重写

面向对象

• 面向对象编程( object-Oriented Programming,OOP)
• 面向对象编程的本质就是：以类的方式组织代码,以对象的组织封装)数据。
• 抽象:编程思想!持续的学习,茅塞顿开!多实践,多测试，多测试大脑中的想法！实践出真知
• 三大特性
  • 封装
  • 继承
  • 多态
• 从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
• 从代码运行角度考虑是先有类后有对象。类是对象的模板。

封装

1.提高数据的安全性

2.隐藏代码的实现细节

3.统一接口

4.系统的可维护性增加了

• 该露的露,该藏的藏

  • 我们程序设计要追求“高内聚,低耦合”高内聚就是类的内部数据操作细节自己完成,不允许外部
  • 干涉;低耦合:仅暴露少量的方法给外部使用。

• 封装(数据的隐藏)

  • 通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏。

记住这句话就够了: 属性私有,get/set,ALT+INSERT选择get and set

继承

在Java中。所有的类都默认直接或者间接继承Object，私有的属性方法无法被继承

• 继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。

• **extends**的意思是“扩展”。子类是父类的扩展。

• JAVA中类只有单继承,没有多继承!

• 继承是类和类之间的一种关系。除此之外类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的俩个类,一个为子类(派生类)一个为父类(基类)。子类继承父类使用关键字 extends来表示。

• 子类和父类之间从意义上讲应该具有"is a"的关系

• object类

• super

• 方法重写---->多态的体现

多态

动态编译：类型最终状态只有在程序执行过程中才可以决定，可拓展性

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多

• 多态存在的条件

  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

• 注意:多态是方法的多态,属性没有多态性。

• instanceof

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的	new Student();new Person();
        //可以指向的引用关型就不确定了:父类的引用指向子类
        //Student 能调用的方法都是自己的或者继承父类的！
        //对象能执行那些方法。主要看对象左边的类型，和右边关系不大
        
        Student s1 = new Student();//子类
        //Persion父类型，可以指向子类，但是不能调用子类独有的方法
        
        Persion s2 = new Student();//父类引用指向子类对象     更灵活 
        
        s2.run();//子类重写了父类的方法，执行子类方法
        
        s2.sss();//s2可以调用父类的方法，也能指向子类重写父类的方法
        
        s2.eat();//父类不能调用子类的方法	可以强制转换：((Student) s2).eat();
    }
}
public class Persion {
    public void run(){
        System.out.println("Persion：run()");
    }
    public void sss(){
        System.out.println("Persion");
    }
}
public class Student extends Persion{
    @Override
    public void run() {
        System.out.println("student:run()");
    }
    public void eat(){
        System.out.println("ear");
    }
}

类型转换

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上造型(自动转)
3. 把父类转换为子类，向下造型(强制转换)
4. 方便方法的调用，减少重复的代码：简洁

从左到右越来越抽

抽象：封装、继承、多态！抽象类，接口

==========

---

重载

方法重载是一个类的多态性表现

Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载

代码：

public class overloading {
    public int add(int a,int b){
        return a+b;
    }
    public int add(int a,int b,int c){
        return a+b+c;
    }
    public int add(int a,int b,int d,int c){
        return a+b+c+d;
    }
    public static void main(String[] args) {
        overloading o = new overloading();
        System.out.println(o.add(1,2));
        System.out.println(o.add(1,2,3));
    }
}

重写

而方法重写是子类与父类的一种多态性表现

在子类中创建了一个与父类中名称相同、返回值类型相同、参数列表的方法相同，

只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写(override)，又称为方法覆盖、方法复写

当需要在子类中调用父类的被重写方法时，要使用 super 关键字

重写：需要有继承关系，子类重写父类的方法！

​ 1.方法名必须相同

​ 2.参数列表必须相同

​ 3.修饰符：范围可以扩大：public --> Protected --> Default --> private

​ 4.抛出的异常：异常的范围可以被缩小，但是不能扩大ClassNotFoundException --> Exception(大)

重写：子类的方法和父类必须一致；方法体不同！

为什么需要重写：

​ 父类的功能，子类不一定需要，或者不一定满足

​ IDEA快捷键：Alt + Insert ; override

代码：

public class Application {
    //静态方法和非静态方法区别很大；
    //      静态方法：方法的调用只和左边定义的数据类型有关
    //      非静态方法：重写
    public static void main(String[] args) {
        A a = new A();
        a.test();		//A-->test()
        //父类的引用指向子类的对象
        B b = new A();//子类重写了父类的方法
        b.test();		//A-->test()
    }
}
public class A extends B{
    //override 重写
    @Override   //注解：有功能的注释
    public void test() {
        System.out.println("A-->test()");
    }
}
public class B{
    public void test(){
        System.out.println("B-->test()");
    }
}

super and this

1. super

1. super调用父类的构造方法，必须在构造方法的第一个，只能放在代码第一行
2. super必须只能出现在子类的方法或者构造方法中！
3. super和this不能同时调用构造方法！

2. this

• 代表的对象不同

  • this:本身调用者这个对象

  • super:代表父类对象的应用

• 前提

  • this:没有继承也可以使用
  • super:只能在继承条件下才可以使用

• 构造方法

  • this:本类的构造
  • super:父类的构造

构造器(构造方法)

作用：一般用来初始化成员属性和成员方法的，即new对象产生后，就调用了对象了属性和方法.

1. 什么是构造方法

• java构造方法，是java中一种特殊的函数。函数名与相同，无返回值。
• 一个对象建立，构造函数只运行一次，而一般函数可以被该对象调用多次。
• 构造函数是对象一建立就运行，给对象初始化，就包括属性，执行方法中的语句。

**就比如：**在现实生活中，很多事物一出现，就天生具有某些属性和行为。比如人一出生，就有年龄、身高、体重、就会哭；汽车一出产，就有颜色、有外观、可以运行等。这些，我们就可以将这些天然的属性和行为定义在构造函数中，当new实例化对象时，也就具有这些属性和方法了，没必要再去重新定义了，从而加快了编程效率。

2. 构造方法的特点

1. 函数名与类名相同

2. 不能定义返回值类型(不同于void类型返回值，void是没有具体返回值类型；构造函数是连类型都没有)

3. 不可以写return语句

4. 当一个类中没有定义构造函数时，系统会给该类中加一个默认的空参数的构造函数，方便该类初始化。只是该空构造函数是隐藏不见的。

5. 当在该类中自定义了构造函数，默认构造函数就没有了。

6. 子类继承父类后，子类构造器中默认有个隐式的构造器在第一行: super();

7. 构造器也可以重载

   public class Persion {
       public Persion() {
           System.out.println("Persion无参执行了");
       }
       public Persion(String name) {//构造器可以重载
           System.out.println("Persion有参执行了");
       }
   }
   
   public class Student extends Persion {
       public Student() {
           //这里藏了一个父类的无参构造: super();
           super();//调用父类的构造器，必须放在代码第一行
           System.out.println("Student无参执行了");
       }
   }
   
   public class Application {
       public static void main(String[] args) {
           Student st = new Student();
           //执行main方法会输出
           //	Persion无参执行了
   		//	Student无参执行了
   }