关于java:Java基础封装和继承

44次阅读

共计 7885 个字符,预计需要花费 20 分钟才能阅读完成。

茫茫人海千千万万,感激这一秒你看到这里。心愿我的文章能对你的有所帮忙!共勉!

愿你在将来的日子,放弃酷爱,奔赴山海!

Java 基础知识(封装和继承)

一. 封装

那封装是什么呢?

在面向对象程式设计办法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节局部包装、暗藏起来的办法。

1.1 封装的目标

  • 间接通过操控类对象来达到目标,不须要对具体实现非常理解,使类属性和办法的具体实现对外不可见。岂但不便还起到了爱护作用。
  • 封装最次要的性能在于咱们能批改本人的实现代码,而不必批改那些调用咱们代码的程序片段。
  • 适当的封装能够让程式码更容易了解与保护,也增强了程式码的安全性。

1.2 封装的益处

  • 良好的封装可能缩小耦合。
  • 类外部的构造能够自在批改。
  • 能够对成员变量进行更准确的管制。
  • 暗藏信息,实现细节。

1.3 封装的步骤

  1. 批改属性的可见性来限度对属性的拜访(个别限度为 private),例如:

    public class Person {
        private String name ; // 姓名
        private String gender ; // 性别
        private int age; // 年龄
    }

这段代码中,将 namesexage 属性设置为公有的,只能本类能力拜访,其余类都拜访不了,如此就对信息进行了暗藏。

  1. 对每个值属性提供对外的公共办法拜访,也就是创立一对赋取值办法,用于对公有属性的拜访,例如:

    public class Person {
        private String name ; // 姓名
        private String gender ; // 性别
        private int age; // 年龄
    
        public void setName(String name) {this.name = name;}
    
        public String getName() {return name;}
    
        public void setGender(String gender) {this.gender = gender;}
        
        public String gender(){return gender;}
        
        public void setAge(int age) {this.age = age;}
    
        public int getAge() {return age;}
    }

采纳 this 关键字调用本类中的属性,也就是类中的成员变量。次要为了解决实例变量(private String name)和局部变量(setName(String name)中的 name 变量)之间产生的同名的抵触。

1.4 封装的例子

  • 创立一个用户类 User:

    代码如下:

    package com.nz.pojo;
    
    public class User {
        private String username; // 用户名
        private String password; // 明码
    
        public String getUsername() {return username;}
    
        public void setUsername(String username) {this.username = username;}
    
        public String getPassword() {return password;}
    
        public void setPassword(String password) {this.password = password;}
    }
  • 编写测试 User 的 demo:EncapsulationDemo

    代码如下:

    package com.nz;
    
    import com.nz.pojo.User;
    
    public class EncapsulationDemo {public static void main(String[] args) {User user = new User();
            user.setUsername("太子爷哪吒");
            user.setPassword("520");
            System.out.println("username:" + user.getUsername() + "-----------"
                                + "password:" + user.getPassword());
        }
    }

执行后果如下:

username: 太子爷哪吒 -----------password520

1.5 小结

封装实际上是将类的某些信息暗藏在类的外部,不容许内部程序间接拜访,而是通过该类提供的办法来实现对暗藏信息的拜访和操作。就是把咱们想提供给外界的一些办法给裸露进去,以便外界能调用到咱们。

二. 继承

2.1 继承的介绍

继承是 java 面向对象编程技术的一块基石,因为它容许创立分等级档次的类。形容的是事物之间的所属关系,这种关系是:is-a 的关系。

继承 :就是子类继承父类的 属性 行为 ,使得子类对象(实例)能够间接具备与父类雷同的属性、雷同的行为。子类能够间接拜访父类中的 非公有 的属性和行为。

2.2 生存中的继承

兔子和长颈鹿属于食草动物类,老虎和狮子属于食肉动物类。而食草动物和食肉动物又是属于动物类。

那是不是兔子、长颈鹿、老虎、狮子都属于动物类呢?答案是没错滴!尽管食草动物和食肉动物都是属于动物,然而两者的属性和行为上有差异,所以子类会具备父类的个别个性也会具备本身的个性。咱们就能够再多个类中存在雷同属性和行为时,咱们能够将这些内容抽取到独自一个类中,那么多个类无需再定义这些属性和行为,只有 继承 那一个类即可。

2.3 继承的益处

  1. 进步 代码的复用性(缩小代码冗余,雷同代码反复利用)。
  2. 使类与类之间产生了关系。
  3. 子类领有父类非 private 的属性、办法。
  4. 子类能够领有本人的属性和办法,即子类能够对父类进行扩大。
  5. 子类能够用本人的形式实现父类的办法。
  6. 进步了类之间的耦合性(继承的毛病,耦合度高就会造成代码之间的分割越严密,代码独立性越差)。
  7. Java 的继承是单继承,然而能够多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 B 类继承 A 类,C 类继承 B 类,所以依照关系就是 B 类是 C 类的父类,A 类是 B 类的父类,这是 Java 继承区别于 C++ 继承的一个个性。

2.4 继承的格局

在 Java 当中会通过 <font color=#ff1493>extends</font> 关键字能够申明一个类是从另外一个类继承而来的,个别模式如下:

class 父类 {
}
 
class 子类 extends 父类 {}

须要留神一点:Java 不反对多继承,但反对多重继承。就如下:

class A {
}
 
class B extends A {(对的)
}

class C extends A, B {(错的)}

class C extends B {(对的)}

顶层父类是 Object 类。所有的类默认继承 Object,作为父类。

2.5 继承的 demo

  • 编写一个父类极其对应的子类信息

    构造如下:

    代码如下:

    父类 Person:

    package com.nz.pojo;
    
    public class Person {
        private String name ;
        private int age ;
    
        public String getName() {return name;}
    
        public void setName(String name) {this.name = name;}
    
        public int getAge() {return age;}
    
        public void setAge(int age) {this.age = age;}
    }

子类 Student 没有额定的属性和办法:

package com.nz.pojo;

/**
 * 继承了 Person 特有的 name, age,* 没有额定的独有属性和办法
 */
public class Student extends Person{}

子类 Teacher 多了一个工资的属性和独有的教书办法:

package com.nz.pojo;

/**
 * 继承了 Person 特有的 name, age,* 多了本人独有的工资属性还有独有的教书办法
 */
public class Teacher extends Person{

    // 工资
    private double salary ;

    // 特有办法
    public void teach(){System.out.println("老师在认真教书!");
    }

    public double getSalary() {return salary;}

    public void setSalary(double salary) {this.salary = salary;}
}
  • 编写测试代码:

    package com.nz;
    
    import com.nz.pojo.Student;
    import com.nz.pojo.Teacher;
    
    public class InheritDemo {public static void main(String[] args) {Teacher teacher = new Teacher();
            teacher.setName("太子爷哪吒");
            teacher.setAge(18);
            teacher.setSalary(1999.99);
            System.out.println(teacher.getName());
            System.out.println(teacher.getAge());
            System.out.println(teacher.getSalary());
            teacher.teach();
    
            Student student = new Student();
            student.setName("哪吒");
            student.setAge(12);
            //student.setSalary(1999.99); // student 没有工资属性,报错!System.out.println(student.getName());
            System.out.println(student.getAge());
        }
    }

后果如下:

太子爷哪吒
18
1999.99
老师在认真教书!哪吒
12

从后果来看,子类继承父类,就能够间接失去父类的成员变量和办法。而子类能够编写一些特有的属性和办法,然而是否能够继承所有成分呢?

2.6 子类不能继承的内容

并不是父类的所有内容都能够给子类继承的:

2.6.1 super 与 this 关键字

这里先将这两个关键字,super 和 this 在继承关系中,使用比拟频繁。

  • super 关键字:咱们能够通过 super 关键字来实现对父类成员的拜访,用来援用以后对象的父类。
  • this 关键字:指向本人本类的援用。

    super 和 this 残缺的用法如下:

    this. 成员变量        --    本类的
    super. 成员变量        --    父类的
    
    this. 成员办法名()      --    本类的    
    super. 成员办法名()   --    父类的
  • 具体演示,创立测试 InheritDemo2:

    package com.nz;
    
    public class InheritDemo2 {public static void main(String[] args) {Animal a = new Animal();
            a.eat();
            Cat cat = new Cat();
            cat.eatFish();}
    }
    
    class Animal {void eat() {System.out.println("animal : eat");
        }
    }
    
    class Cat extends Animal {void eat() {System.out.println("cat : eat");
        }
        void eatFish() {this.eat();   // this 调用本人的办法
            super.eat();  // super 调用父类办法}
    }

调用后果如下:

animal : eat
cat : eat
animal : eat
  • 留神:

    子类的每个构造方法中均有默认的 super(),调用父类的空参结构。手动调用父类结构会笼罩默认的 super()。

    super() 和 this() 都必须是在构造方法的第一行,所以不能同时呈现。

2.6.2 结构器不能被继承

  • 子类不能继承父类的结构器(构造方法或者构造函数),它只是 调用(隐式或显式)。因为子类有本人的结构器。值得注意的是子类能够继承父类的公有成员(成员变量,办法),只是子类无奈间接拜访而已,能够通过 <font color=#ff1493>getter/setter</font> 办法拜访父类的 private 成员变量。
  • 如果父类的结构器带有参数,则必须在子类的结构器中显式地通过 <font color=#ff1493>super </font> 关键字调用父类的结构器并配以适当的参数列表。
  • 如果父类结构器没有参数,则在子类的结构器中不须要应用 <font color=#ff1493>super </font> 关键字调用父类结构器,零碎会主动调用父类的无参结构器。
  • 演示过程:

    package com.nz;
    
    public class InheritDemo3  {public static void main(String[] args) {System.out.println("------Teacher 类继承 ------");
            Teacher teacher = new Teacher();
            Teacher teacher2 = new Teacher("张三");
            System.out.println("------Student 类继承 ------");
            Student student = new Student();
            Student student2 = new Student("张三三");
        }
    }
    // 父类
    class Person {
        private String name;
        Person(){System.out.println("调用了父类的无参结构器: Person()");
        }
        Person(String name) {System.out.println("调用了父类的带参结构器: Person(String name)");
            this.name = name;
        }
    }
    // Teacher 子类继承 Person
    class Teacher extends Person{
        private String name;
        Teacher(){// 主动调用父类的无参数结构器 因为会有默认 super();
            System.out.println("Teacher");
        }
    
        public Teacher(String name){super("太子爷哪吒");  // 调用父类中带有参数的结构器
            System.out.println("Teacher(String name):"+name);
            this.name = name;
        }
    }
    // Student 子类继承 Person
    class Student extends Person{
        private String name;
    
        Student(){super("heihei");  // 调用父类中带有参数的结构器
            System.out.println("SubClass2");
        }
    
        public Student(String name){ // 主动调用父类的无参数结构器
            System.out.println("Student(String name):"+name);
            this.name = name;
        }
    }

后果如下:

------Teacher 类继承 ------
调用了父类的无参结构器: Person()
Teacher
调用了父类的带参结构器: Person(String name)
Teacher(String name): 张三
------Student 类继承 ------
调用了父类的带参结构器: Person(String name)
SubClass2
调用了父类的无参结构器: Person()
Student(String name): 张三三

2.6.3 final 润饰的类不能被继承

final 关键字次要用在三个中央:变量、办法、类。

  1. 润饰类:示意该类不能被继承;
  2. 润饰办法:示意办法不能被重写;
  3. 润饰变量:示意变量只能一次赋值当前值不能被批改(常量)。

final 的特点:

  • 对于一个 final 变量,如果是根本数据类型的变量,则其数值一旦在初始 化之后便不能更改;如果是援用类型的变量,则在对其初始化之后便不 能再让其指向另一个对象。
  • 当用 final 润饰一个类时,表明这个类不能被继承。final 类中的所有成员 办法都会被隐式地指定为 final 办法。
  • 应用 final 办法的起因有两个。第一个起因是把办法锁定,以防任何继承 类批改它的含意;第二个起因是效率。在晚期的 Java 实现版本中,会将 final 办法转为内嵌调用。然而如果办法过于宏大,可能看不到内嵌调用 带来的任何性能晋升(当初的 Java 版本曾经不须要应用 final 办法进行这些优化了)。类中所有的 private 办法都隐式地指定为 final。

咱们测试下润饰类后到底能不能继承:

package com.nz;

public class InheritDemo4 {
}

// 父类
final class Fu {private String name;}

//class Zi extends Fu{ // Cannot inherit from final 'com.nz.Fu' 会显示没方法继承 Fu
//}

后果:能够看进去在被 final 润饰的 Fu 类没方法继承,而且在编译期间就会报错了,没方法通过运行。

2.7 办法重写

2.7.1 介绍

子类中呈现与父类截然不同的办法时(返回值类型,办法名和参数列表都雷同),会呈现笼罩成果,也称为重写或者复写。申明不变,从新实现

2.7.2 应用场景与案例

产生在子父类之间的关系。
子类继承了父类的办法,然而子类感觉父类的这办法不足以满足本人的需要,子类从新写了一个与父类同名的办法,以便笼罩父类的该办法。

写个测试案例:

package com.nz;

public class InheritDemo5 {public static void main(String[] args) {
        // 创立子类对象
        Cat lanMao = new Cat();
        // 调用父类继承而来的办法
        lanMao.run();
        // 调用子类重写的办法
        lanMao.sing();}
}

class Animal{public void sing(){System.out.println("动物都能够唱歌!");
    }
    public void run(){System.out.println("动物都能够跑!");
    }
}

class Cat extends Animal {public void sing(){System.out.println("咱们一起学猫叫,一起喵喵喵!让咱们一起撒个娇");
    }
}

运行后果:

动物都能够跑!咱们一起学猫叫,一起喵喵喵!让咱们一起撒个娇

能够看出,蓝猫调用了重写后的 sing 办法。

2.7.2 @Override 重写注解

  • @Override:注解,重写注解 校验
  • 这个注解标记的办法,就阐明这个办法必须是重写父类的办法,否则编译阶段报错。
  • 倡议重写都加上这个注解,一方面能够进步代码的可读性,一方面能够避免重写出错!

    加上后的子类代码模式如下:

    class Cat extends Animal {
        // 申明不变,从新实现
        // 办法名称与父类全副一样,只是办法体中的性能重写了!@Override
        public void sing(){System.out.println("咱们一起学猫叫,一起喵喵喵!让咱们一起撒个娇");
        }
    }

2.7.3 注意事项

  1. 办法重写是产生在子父类之间的关系。
  2. 子类办法笼罩父类办法,必须要保障权限大于等于父类权限。
  3. 子类办法笼罩父类办法,返回值类型、函数名和参数列表都要截然不同。

2.8 小结

继承是应用已存在的类的定义作为根底建设新类的技术,新类的定义能够减少新的数据或新的性能,也能够用父类的性能,但不能选择性地继承父类。通过应用继承咱们可能十分不便地复用以前的代码。

注: 如果文章有任何谬误和倡议,请各位大佬纵情留言!如果这篇文章对你也有所帮忙,心愿可恶亲切的您给个三连关注下,非常感谢啦!也能够微信搜寻 太子爷哪吒公众号 进行私聊我,感激各位大佬!

正文完
 0