Java基础

ryluo 2020-06-14 01:29:22

JVM,Java编译器与Java虚拟机:

参考资料:https://www.jianshu.com/p/2698d5a2603c


类与对象的区别:


重写与重载的区别

重载:指的是同一个类中允许同时存在一个以上的同名方法,只要这些方法的参数或者类型不同即可。

注意:虽然在方法重载中可以使用两个方法的返回类型不同,但只有返回类型不同并不足以区分两个方法的重载,还需要通过参数的个数以及参数的类型来设置。

public class OverLoadTest {

    public static int add(int a, int b) {
        return a + b;
    }

    public static double add(double a, double b) {
        return a + b;
    }

    public static int add(int a, int b, int c) {
        return a + b + c;
    }

    public static double add(double a, double b, double c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        System.out.println("add(int a, int b): " + add(1, 2));
        System.out.println("add(double a, double b): " + add(1.2, 3.5));
        System.out.println("add(int a, int b, int c): " + add(1, 3, 5));
        System.out.println("add(double a, double b, double c): " + add(1.2, 3.5, 4.5));
    }
}

执行结果:

add(int a, int b): 3
add(double a, double b): 4.7
add(int a, int b, int c): 9
add(double a, double b, double c): 9.2

重载的规则:

(1)必须具有不同的参数列表。

(2)可以有不同的返回类型,只要参数列表不同就可以了。

(3)可以有不同的访问修饰符。

(4)可以抛出不同的异常。


重写:也称为覆盖,指的是子类中将父类的成员方法的名称保留,重写成员方法的实现内容,更改成员方法的存取权限,或是修改成员方法的返回值

父类:

public class Parent {
    // 构造方法
    public Parent(){
        System.out.println("父类的构造方法");
    }

    // 成员方法
    public void doSomething(){
        System.out.println("父类的方法");
    }

    protected Parent doIt() {
        return new Parent();
    }
}

子类:

public class Children extends Parent{ // 继承父类
    // 子类的构造方法
    public Children() {
        // 调用父类的构造方法
        super();

        // 调用父类的成员方法
        super.doSomething();

        // 子类构造方法
        System.out.println("子类构造方法");
    }

    // 子类新增方法
    public void doSomethingnew(){
        System.out.println("子类新增方法");
    }

    // 重写父类方法
    public void doSomething(){
        System.out.println("子类重写父类方法");
    }

    // 重写父类方法,返回值位Children
    protected Children doIt(){
        return new Children();
    }
}

重写的规则:

(1)参数列表必须完全与被重写的方法相同,否则不能称其为重写而是重载。

(2)访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)。

(3)重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如:父类的一个方法申明了一个检查异常IOException,在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常,可以抛出非检查异常。


封装的概念

封装指的是:将类中的实例变量标记位私有的,并提供共有的getter或者setter来控制存取动作。

封装的好处:

  1. 隐藏了类的具体实现
  2. 操作简单
  3. 提高对象数据的安全性


多态

多态存在的三个条件:

  1. 要有继承关系
  2. 子类要重写父类的方法
  3. 父类的引用指向子类对象

接口

参考资料