Java : 封装、继承、多态

目录标题

  • 封装
    • 封装的概念
    • 访问限定符
    • 封装扩展之包
  • 继承
    • 继承概念
    • 父类成员访问
    • super关键字
    • 子类构造方法
    • super和this的区别
    • protected关键字
  • 多态
    • 多态的概念&重写&多态实现条件
    • 向上转型和向下转型
    • 多态的优缺点

封装

封装的概念

封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互
例如:计算机厂商在出厂时,在外部套上壳子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以及键盘插孔等,让用户可以与计算机进行交互即可。

访问限定符

Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符:
可以修饰方法/成员/类

No 范围 private default protected public
1 同一包中的同一类 Yes Yes Yes Yes
2 同一包中的不同类 Yes Yes Yes
1 不同包中的子类 Yes Yes
1 不同包中的非子类 Yes

public:可以理解为一个人的外貌特征,谁都可以看得到
default: 对于自己家族中(同一个包中)不是什么秘密,对于其他人来说就是隐私了
private:只有自己知道,其他人都不知道(被private修饰的属性,只能在当前类当中使用。什么是当前类?找大括号->类的大括号)

封装扩展之包

包的概念
为了更好的管理类,把多个类收集在一起成为一组,称为软件包。包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,比如:一个包中的类不想被其他包中的类使用。包还有一个重要的作用:在同一个工程中允许存在相同名称的类,只要处在不同的包中即可。
Java : 封装、继承、多态_第1张图片
导入包中的类

//但是这种写法比较麻烦一些, 可以使用 import语句导入包.例如:import java.util.Date;
//如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
public class Test1 {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();// 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}
//但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.
//如果util包和sql包都存在一个Date这样的类,就会出现歧义,编译出错,编译器也不知道要导入哪一个包中的类

import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要。import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using。

自定义包

  • 在文件的最上方加上一个 package 语句指定该代码在哪个包中
  • 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.baidu1 ).
  • 包名要和代码路径相匹配. 例如创com.baidu1 的包, 那么会存在一个对应的路径 com/demo1 来存储代码.
    如果一个类没有 package 语句, 则该类被放到一个默认包中.

如何新建一个包?

  1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包
  2. 在弹出的对话框中输入包名, 例如 com.baidu
  3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可
  4. 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句
//package声明java文件在哪个包当中
package com.baidu;
public class Test3 {
    String name = "zhangsan";
}
//----------------------------
//同一个包中不同类可以访问
package com.baidu;
public class Test {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        System.out.println(test3.name);
    }
}
//------------------------------
//不同包不能访问
package com.baidu.baidu2;
import com.baidu.Test3;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 86191
 * Date: 2023-03-20
 * Time: 15:38
 */
public class Test2 {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        System.out.println(test3.name);
    }
}

包的访问控制权限控制举例

//Test1位于com.baidu1包中,Test2位于com.baidu2
package com.baidu1;

import com.baidu2.Test2;
public class Test1 {
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        System.out.println(test2.age);
        //System.out.println(test2.name);//会报错,name是default,不允许被其他包中的类访问
        System.out.println(test2.sex);//sex是私有的,不允许被其他类访问
    }
}

//--------------------------------------------
package com.baidu2;

import com.baidu1.Test1;
public class Test2 {
    String name = "张三";//不加访问权限默认是default
    public int age = 10;
    private String sex = "男";
}

继承

继承概念

继承(inheritance)机制:允许在保持原有类特性的基础上进行扩展,增加新功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构, 体现了由简单到复杂的认知过程。继承主要解决的问题是:共性的抽取,实现代码复用。

继承语法
修饰符 class 子类 extends 父类 {
// …
}

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }
}
class Dog {
    //public String name;
    //public int age;
    public float weight;
    /*public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }*/
    public void bark() {
        System.out.println(name+" 正在汪汪");
    }
}
class Cat {
    //public String name;
    //public int age;
    public String hair;
    /*public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }*/
    public void CatchMouse() {
        System.out.println(name+" 正在抓老鼠");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog类中并没有定义任何成员变量,name和age属性肯定是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        //dog访问的eat()和sleep()方法也是从Animal中继承下来的
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

Java : 封装、继承、多态_第2张图片

  1. 子类会将父类中的成员变量或者成员方法继承到子类中了
  2. 子类继承父类之后,要新添加自己特有的成员,体现出与基类的不同。

Dog和Cat都继承了Animal类,其中:Animal类称为父类/基类或超类,Dog和Cat可以称为Animal的子类/派生类,继承之后,子类可以复用父类中成员,子类在实现时只需关心自己新增加的成员即可。
继承概念中可以看出继承最大的作用就是:实现代码复用

父类成员访问

子类中访问父类的成员变量

class Base {
    int a;
    int b;
    int c;
}
class Derived extends Base{
    int a = 199; // 与父类中成员a同名,且类型相同
    int b; // 访问从父类中继承下来的b
    public void method(){
        System.out.println(a); // 访问自己的a
        System.out.println(super.a);//通过super可以访问父类的成员的a
        System.out.println(c); // 子类没有c,访问的肯定是从父类继承下来的c
         System.out.println(d); //  编译失败,因为父类和子类都没有定义成员变量b
    }
}
public class Test1 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}

在子类方法中 或者 通过子类对象访问成员时:

  • 如果访问的成员变量子类中有,优先访问自己的成员变量。
  • 如果访问的成员变量子类中无,则访问父类继承下来的,如果父类也没有定义,则编译报错。
  • 如果访问的成员变量与父类中成员变量同名,则优先访问自己的

成员变量访问遵循就近原则,自己有优先自己的,如果没有则向父类中找。

子类中访问父类的成员方法

class Base1 {
    int a;
    int b;
    public void methodA() {
        System.out.println("AAA");
    }
     public void methodB() {
        System.out.println("DDD");
    }
}
class Derived1 extends Base1{
    int a = 199; // 与父类中成员a同名,且类型相同
    int b; // 与父类中成员b同名,但类型不同
    int c;
    public void method() {
        System.out.println("CCC");
    }
    //methodA(char ch)和父类methodA()构成了重载,说明了方法的重载不一定要在同一个类中
    public void methodA(char ch) {
        System.out.println("BBB");
    }

    public void test() {
        methodB();//子类没有,调用父类的
        method();//当子类没有不带参数的method的方法时候就会调用父类
        method('c');//子类有带参数的method方法时,就会调用子类的method方法
    }
}

public class Test2 {
    public static void main(String[] args) {
        Derived1 derived = new Derived1();
        derived.test();
    }
}
  • 通过子类对象访问父类与子类中不同名方法时,优先在子类中找,找到则访问,否则在父类中找,找到则访问,否则编译报错。
  • 通过派生类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错;

总结:成员方法没有同名时,在子类方法中或者通过子类对象访问方法时,则优先访问自己的,自己没有时再到父类中找,如果父类中也没有则报错.

super关键字

super关键字,该关键字主要作用:在子类方法中访问父类的成员。

//在子类方法中,如果想要明确访问父类中成员时,借助super关键字即可
class Base2 {
    int a;
    int b;
    public void methodA() {
        System.out.println("AAA");
    }
    public void methodB() {
        System.out.println("访问父类类中的methodB()");
    }
}
class Derived2 extends Base2{
    int a = 199;//  与父类中成员变量同名且类型相同
    int b;
    int c;
    public void methodB() {
        System.out.println("BBB");
    }
    public void methodA(char ch) {
        System.out.println("AAA");
    }
    public void test() {
        System.out.println(super.a);//访问父类成员中的a
        methodA('c');//访问子类中的methodA()
        super.methodB();//访问父类中methodB()
    }
}

public class Test3 {
    public static void main(String[] args) {
        Derived2 derived = new Derived2();
        derived.test();
    }
}
  1. 只能在非静态方法中使用
  2. 在子类方法中,访问父类的成员变量和方法。

子类构造方法

父子父子,先有父再有子,即:子类对象构造时,需要先调用基类构造方法,然后执行子类的构造方法。

class Base4 {
    public Base4() {
        System.out.println("Base()");
    }
}
class Derived4 extends Base4{
    public Derived4(){
    // super(); // 注意子类构造方法中默认会调用基类的无参构造方法:super(),
    // 用户没有写时,编译器会自动添加,而且super()必须是子类构造方法中第一条语句,
    // 并且只能出现一次
        System.out.println("Derived()");
    }
}
public class Test {
    public static void main(String[] args) {
        Derived4 d = new Derived4();
    }
}

在子类构造方法中,并没有写任何关于基类构造的代码,但是在构造子类对象时,先执行基类的构造方法,然后执行子类的构造方法,因为:子类对象中成员是有两部分组成的,基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用基类的构造方法,将从基类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整

  1. 若父类显式定义无参或者默认的构造方法,在子类构造方法第一行默认有隐含的super()调用,即调用基类构造方法
  2. 如果父类构造方法是带有参数的,此时需要用户为子类显式定义构造方法,并在子类构造方法中选择合适的父类构造方法调用,否则编译失败。
  3. 在子类构造方法中,super(…)调用父类构造时,必须是子类构造函数中第一条语句。
  4. super(…)只能在子类构造方法中出现一次,并且不能和this同时出现

super和this的区别

super和this都可以在成员方法中用来访问:成员变量和调用其他的成员函数,都可以作为构造方法的第一条语句,那他们之间有什么区别呢?

相同点:

  1. 都是Java中的关键字
  2. 只能在类的非静态方法中使用,用来访问非静态成员方法和字段
  3. 在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在

不同点:

  1. this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象中从父类继承下来部分成员的引用
  2. 在非静态成员方法中,this用来访问本类的方法和属性,super用来访问父类继承下来的方法和属性
  3. 在构造方法中:this(…)用来调用本类的构造方法,super(…)用于调用父类构造方法,两种调用不能同时在构造方法中出现
  4. 构造方法中一定会存在super(…)的调用,用户没有写编译器也会增加,但是this(…)用户不写则没有

protected关键字

  1. 声明为protected的方法和成员变量能被同一个包里的所有类所访问,就像默认修饰符package一样。
  2. 能被该类的子类所访问,子类可以和父类不在一个包中。
  3. 能被该类的子类所访问,子类可以和父类不在一个包中。
  4. 在子类中,子类实例可以访问其从基类继承而来的protected方法,而不能访问基类实例的protected方法。
package Demo2;
public class Test1 {
    protected int a = 199;

    public static void main(String[] args) {
        Test1 test1 = new Test1();
        System.out.println(test1.a);
    }
}

//---------------------------------
package Demo2;
public class Test2 {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        System.out.println(test1.a);
    }
}

//---------------------------------
package Demo3;
import Demo2.Test1;
public class Test3  extends Test1 {
    public void func() {
        System.out.println(super.a);
    }
    public static void main(String[] args) {
        Test3 test3 =new Test3();
        test3.func();
    }
}

多态

多态的概念&重写&多态实现条件

多态的概念:就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。
Java : 封装、继承、多态_第3张图片
总的来说:同一件事情,发生在不同对象身上,就会产生不同的结果。

重写

 class Animal {
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
 class Cat extends Animal{
    public Cat(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
}
 class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
        dog.eat();
    }
}

重写(override):也称为覆盖。重写是子类对父类非静态、非private修饰,非final修饰,非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

  • 子类在重写父类的方法时,一般必须与父类方法原型一致: 返回值类型 方法名 (参数列表) 要完全一致
  • 子类的访问修饰限定符一定要大于等于父类的访问修饰限定符。例如:如果父类方法被public修饰,则子类中重写该方法就不能声明为 protected(private <包访问权限
  • 父类被static、private修饰的方法、构造方法都不能被重写。
  • 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

Java : 封装、继承、多态_第4张图片

//动态绑定:也称为后期绑定(晚绑定),即在编译时,不能确定方法的行为,需要等到程序运行时,才能够确定具体调用那个类的方法
 class Animal {
    String name;
    int age;
     Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}

 class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test {
     public static void eat(Animal a) {
         a.eat();
     }
    public static void main(String[] args) {
        /* Dog dog = new Dog("wangcai",10);
        Animal animal = dog;*/
        Animal animal1 = new Dog("wangwang",11);
        animal1.eat();
        //1.父类与子类发生了重写
        //2.通过父类的引用调用eat方法,发生动态绑定
    }
}
//运行结果:
//wangwang吃骨头~~~

//-------------------------------------
//静态绑定:称为前期绑定(早绑定),即在编译时,根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载
public class Test2 {
    public int x;
    public int y;
    public int getx() {
        return x;
    }
    public int gety() {
        return y;
    }
    public int add(int a,int b) {
        return a+b;
    }
    public int add(int a,int b,int c) {
        return a+b+c;
    }
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        int sum1 = test2.add(1,2);
        int sum2 = test2.add(1,2,3);
        System.out.println("sum1 = " + sum1);
        System.out.println("sum2 = " + sum2);
    }
}

多态的实现条件

  1. 必须在继承体系下
  2. 子类必须要对父类中方法进行重写
  3. 通过父类的引用调用重写的方法
//多态体现:在代码运行时,当传递不同类对象时,会调用对应类中的方法
class Animal1 {
    String name;
    int age;
    public Animal1(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
class Cat1 extends Animal{
    public Cat1(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
}
class Dog1 extends Animal {
    public Dog1(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test2 {
    // 编译器在编译代码时,并不知道要调用Dog还是Cat中eat的方法
    // 等程序运行起来后,形参animal引用的具体对象确定后,才知道调用那个方法
   // 注意:此处的形参类型必须时父类类型才可以
    public static void eat(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Cat1 cat = new Cat1("旺财",2);
        Dog1 dog = new Dog1("阿七", 1);
        eat(dog);
        eat(cat);
    }
}

总结:父类引用 引用子类对象,当引用的子类对象不一样的时候,通过这个给父类引用调用父类和在子类重写的方法的时候,此时同一个引用呈现出来了不同的状态,我们把这个思想叫做多态

向上转型和向下转型

向上转型
向上转型:实际就是创建一个子类对象,将其当成父类对象来使用

语法格式:父类类型 对象名 = new 子类类型()
Animal animal = new Cat(“张三”,2);

animal是父类类型,但可以引用一个子类对象,因为是从小范围向大范围的转换。

//使用场景
//1. 直接赋值 
Animal animal1 = new Dog("wangwang",11);
//2. 方法传参
 public static void eat(Animal animal){
        animal.eat();
    }
//3. 方法返回
 public static Animal getAnimal() {
        return new Dog();
}
//向上转型的优点:让代码实现更简单灵活。
//向上转型的缺陷:不能调用到子类特有的方法
//将一个子类对象经过向上转型之后当成父类方法使用,再无法调用子类的方法,但有时候可能需要调用子类特有的方法,此时:将父类引用再还原为子类对象即可,即向下转换。
class Animal1 {
    String name;
    int age;
    public Animal1(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
class Cat1 extends Animal{
    public Cat1(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
    public void mimi() {
        System.out.println(name+"咪咪叫");
    }
}
class Dog1 extends Animal {
    public Dog1(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
    public void bark() {
        System.out.println(name+"汪汪汪");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Animal animal = new Dog1("wangcai",1);
//animal本来指向的就是狗,因此将animal还原为狗也是安全的
        Dog1 dog = (Dog1) animal;//强制类型转换为Dog
        dog.bark();
//程序可以通过编程,但运行时抛出异常---因为:animal实际指向的是狗
//现在要强制还原为猫,无法正常还原,运行时抛出:ClassCastException
        //Cat1 cat1 = (Cat1) animal;
        //cat1.mimi();
        
//向下转型用的比较少,而且不安全,万一转换失败,运行时就会抛异常。Java中为了提高向下转型的安全性,引入了 instanceof ,如果该表达式为true,则可以安全转换。
if (animal instanceof Cat) {
            Cat1 cat1 = (Cat1) animal;
            cat1.mimi();
        }
    }
    //instanceof判断其左边对象是否为其右边类的实例,返回的是boolean类型的数据

多态的优缺点

优点:

  1. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
  2. 可扩展能力更强

缺点:

  1. 属性没有多态性
    父类引用只能访问父类的方法和属性,而不能访问子类特有的方法和属性。如果需要访问子类特有的方法和属性,就需要进行类型强制转换。
    2.在构造方法中调用重写的方法
class B {
    public B() {
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
        //D这个对象没有构造完成,所以num还没有被初始化
    }
}
public class Test2 {
    public static void main(String[] args) {
        D d = new D();
    }
}
  • 构造 D 对象的同时, 会调用 B 的构造方法.
  • B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
  • 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0
  • 所以在构造函数内,尽量避免使用实例方法

总结:用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

你可能感兴趣的:(Java,java,开发语言)