java基础 -- > 封装,继承,多态

封装:

首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系

封装符合面向对象设计原则的第一条:单一性原则,一个类把自己该做的事情封装起来,而不是暴露给其他类去处理,当内部的逻辑发生变化时,外部调用不用因此而修改,他们只调用开放的接口,而不用去关心内部的实现

继承:

java的类可以分为三种类型:

  1. 类:使用class定义,没有抽象方法
  2. 抽象类:使用abstract class定义,可以有也可以没有抽象方法
  3. 接口:使用inerface定义,只能有抽象方法

在这三个类型之间存在如下关系:

  • 类可以extends:类、抽象类(必须实现所有抽象方法),但只能extends一个,可以implements多个接口(必须实现所有接口方法)
  • 抽象类可以extends:类,抽象类(可全部、部分、或者完全不实现父类抽象方法),可以implements多个接口(可全部、部分、或者完全不实现接口方法)
  • 接口能extends多个接口 (???不理解)

继承以后子类可以得到什么:

  • 子类拥有父类非private的属性和方法(//这里其实我是持怀疑态度,之前听到过一种说法,子类继承了父类所有的成员,也包括private修饰的,只是不能够调用罢了,如果有人知道,欢迎留言讨论)
  • 子类可以添加自己的方法和属性,即对父类进行扩展
  • 子类可以重新定义父类的方法,即多态里面的覆盖,后面会详述
    关于构造函数:

构造函数不能被继承,子类可以通过super()显示调用父类的构造函数
创建子类时,编译器会自动调用父类的 无参构造函数
如果父类没有定义无参构造函数,子类必须在构造函数的第一行代码使用super()显示调用

类默认拥有无参构造函数,如果定义了其他有参构造函数,则无参函数失效,所以父类没有定义无参构造函数,不是指父类没有写无参构造函数。看下面的例子,父类为Human,子类为Programmer。

public class Human
{
    //定义了有参构造函数,默认无参构造函数失效
    public Human(String name)
    {
    }
}
public class Programmer
    extends Human
{
    public Programmer()
    {
        //如不显示调用,编译器会出现如下错误
        //Implicit super constructor Human() is undefined. Must explicitly invoke another constructor
        super( "x" );
    }
}

为什么需要继承:

  • 代码重用是一点,最重要的还是所谓向上转型,即父类的引用变量可以指向子类对象,这是Java面向对象最重要特性多态的基础

多态:

多态: 是在继承的基础上的内容,指的是两个以上的类存在的情况
重载: 是同一个类中出现的方法名相同,参数不同的形式

在了解多态之前,首先需要知道方法的唯一性标识即什么是相同/不同的方法:

  • 一个方法可以由:修饰符如public、static+返回值+方法名+参数+throw的异常 5部分构成
  • 其中只有方法名和参数是唯一性标识,意即只要方法名和参数相同那他们就是相同的方法
  • 所谓参数相同,是指参数的个数,类型,顺序一致,其中任何一项不同都是不同的方法

何谓重载:

  • 重载是指一个类里面(包括父类的方法)存在方法名相同,但是参数不一样的方法,参数不一样可以是不同的参数个数、类型或顺序
    如果仅仅是修饰符、返回值、throw的异常 不同,那这是2个相同的方法,编译都通不过,更不要说重载了
//重载的例子  同一个类中出现的现象
public class Programmer extends Human
{
    public void coding() throws Exception {
 
    }
 
    public void coding( String langType ) {
 
    }
 
    public String coding( String langType, String project ) {
        return "";
    }
}

//这不是重载,而是三个相同的方法,编译报错

public class Programmer extends Human {
    public void coding() throws Exception {
 
    }
 
    public void coding() {
 
    }
 
    public String coding() {
        return "";
    }
}

何谓覆盖/重写:

  • 覆盖描述存在继承关系时子类的一种行为
  • 子类中存在和父类相同的方法即为覆盖,何谓相同方法请牢记前面的描述,方法名和参数相同,包括参数个数、类型、顺序
public class Human {
    public void coding( String langType ) {
 		System.out.println( "I am Human" + langType  );
    }
}
public class Programmer extends Human {
    //此方法为覆盖/重写
    public void coding( String langType ) {
 		System.out.println( "I am Programmer , 我重写了父亲的方法" + langType );
    }
 
    //此方法为上面方法的重载
    public void coding( String langType, String project ) {
 		System.out.println( "I am Programmer, 我重载了同一个类中的方法" + langType + "第二个参数, 我有俩参数" + project );
    }
}

覆盖/重写的规则:(两同两小一大原则)

  • 子类不能覆盖父类private的方法,private对子类不可见,如果子类定义了一个和父类private方法相同的方法,实为新增方法
  • 重写方法的修饰符一定要大于被重写方法的修饰符(public > protected > default > private)
  • 重写抛出的异常需与父类相同或是父类异常的子类,或者重写方法干脆不写throws
  • 重写方法的返回值必须与被重写方法一致,否则编译报错
  • 静态方法不能被重写为非静态方法,否则编译出错

理解了上述知识点,是时候定义多态了:

  • 多态可以说是**“一个接口,多种实现”**或者说是父类的引用变量可以指向子类的实例,被引用对象的类型决定调用谁的方法,但这个方法必须在父类中定义
  • 多态可以分为两种类型:编译时多态(方法的重载)运行时多态(继承时方法的重写),编译时多态很好理解,后述内容针对运行时多态
    运行时多态依赖于继承、重写和向上转型
class Human {
    public void showName() {
        System.out.println( "I am Human" );
    }
}
 
//继承关系
class Doctor extends Human {
    //方法重写
    public void showName() {
        System.out.println( "I am Doctor" );
    }
}
 
class Programmer extends Human {
    public void showName() {
        System.out.println( "I am Programmer" );
    }
}
 
public class Test {
    //向上转型
    public Human humanFactory( String humanType ) {
        if( "doctor".equals( humanType ) ) {
            return new Doctor();
        }
        if( "programmer".equals( humanType ) ) {
            return new Programmer();
        }
        return new Human();
    }
 
    public static void main( String[] args) {
        Test test = new Test();
        Human human = test.humanFactory( "doctor" );
        human.showName();//Output:I am Doctor
        human = test.humanFactory( "programmer" );
        human.showName();//Output:I am Programmer
        //一个接口的方法,表现出不同的形态,意即为多态也
    }
}

一个接口的方法,表现出不同的形态,意即为多态也

最近看腾讯的一道多态面试题:(转载自 http://blog.csdn.net/qq_27258799)

public class A {    
    public int a = 0;
    public void fun() {
        System.out.println("-----A-----");
    }
}
 
public class B extends A {
    public int a = 1;
    public void fun() {
        System.out.println("-----B-----");
    }
 
public static void main(String[] args) {
        A classA = new B();     
        System.out.println(classA.a);
        classA.fun();
    }   
}

答案是:

0
-----B-----

解析:
java中变量不能重写,可以按如下口诀记忆:
变量 多态看 左边,
方法 多态看 右边,
静态 多态看 左边。

参考文档 = https://blog.csdn.net/zjkC050818/article/details/78278658?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.compare&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.compare

参考面试: 腾讯一面

©️2020 CSDN 皮肤主题: 黑客帝国 设计师:上身试试 返回首页