• Java笔记七（封装，继承与多态）

    封装

    该露的露，该藏的藏

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

    封装（数据的隐藏）

    通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问

    属性私有

    1. package com.oop.demo04;
    2. //类 private:私有
    3. public class Student {
    4.     //属性私有
    5.     private String name; //名字
    6.     private int id;   //学号
    7.     private char sex;    //性别
    1. package com.oop.demo04;
    2.  
    3. public class Application {
    4.     public static void main(String[] args) {
    5.         Student s1=new Student();
    6.         s1.name//错误代码
    7.     }
    8. }

    此时如果直接调用s1.name则会报错，因为属性私有

    正确方法：

    1. package com.oop.demo04;
    2. //类 private:私有
    3. public class Student {
    4.     //属性私有
    5.     private String name; //名字
    6.     private int id;   //学号
    7.     private char sex;    //性别
    8.  
    9.     //提供一些可以操作这个属性的方法
    10.     //提供一些public的get.set方法
    11.     //get获得这个数据
    12.     public  String getName(){
    13.         return this.name;
    14.     }
    15.     //set给这个数据设置值
    16.     public void setName(String name){
    17.         this.name=name;
    18.     }
    19.  
    20. }
    1. package com.oop.demo04;
    2.  
    3. public class Application {
    4.     public static void main(String[] args) {
    5.         Student s1=new Student();
    6.         s1.setName("佳伟");
    7.         System.out.println(s1.getName());
    8.     }
    9. }

    快捷键alt+ins快速生成get和set方法

    对用户的输入进行限制，以年龄为例：

    1. package com.oop.demo04;
    2. //类 private:私有
    3. public class Student {
    4.     //属性私有
    5.     private String name; //名字
    6.     private int id;   //学号
    7.     private char sex;//性别
    8.     private int age;
    9.  
    10.     //提供一些可以操作这个属性的方法
    11.     //提供一些public的get.set方法
    12.     //get获得这个数据
    13.     public  String getName(){
    14.         return this.name;
    15.     }
    16.  
    17.     public int getAge() {
    18.         return age;
    19.     }
    20.  
    21.     public void setAge(int age) {//对输入不合法的年龄进行限制
    22.         if (age>120||age<0){
    23.             this.age=3;
    24.         }else {
    25.             this.age=age;
    26.         }
    27.     }
    28.  
    29.     //set给这个数据设置值
    30.     public void setName(String name){
    31.         this.name=name;
    32.  
    33.  
    34.     }
    35.  
    36. }
    1. package com.oop.demo04;
    2.  
    3. public class Application {
    4.     public static void main(String[] args) {
    5.         Student s1=new Student();
    6.         s1.setName("佳伟");
    7.         System.out.println(s1.getName());
    8.         s1.setAge(999);
    9.         System.out.println(s1.getAge());
    10.     }
    11. }

    此时年龄便会输出不合法

    封装的意义：

    1.提高程序的安全性，保护数据

    2.隐藏代码的实现细节

    3.统一接口

    4.系统可维护性

    继承

    继承的本质是对某一批类的抽象

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

    JAVA中类只有单继承，没有多继承

    继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

    假设Person是父类，Student与Teacher是子类

    则可这样写

    1. package com.oop.demo05;
    2.  
    3. public class Person {
    4. }
    1. package com.oop.demo05;
    2.  
    3. public class Student extends Person {
    4. }
    1. package com.oop.demo05;
    2.  
    3. public class Teacher extends Person {
    4. }

    子类继承父类，就会拥有父类的全部方法

    1. package com.oop.demo05;
    2.  
    3. public class Person {
    4.     public void say(){
    5.         System.out.println("说了一句话");
    6.     }
    7. }
    1. package com.oop.demo05;
    2.  
    3. public class Application {
    4.     public static void main(String[] args) {
    5.         Student student=new Student();
    6.         student.say();
    7.     }
    8. }

    但是拥有父类的所有方法不代表可以使用父类的所有方法，例如使用封装的关键词private

    1. package com.oop.demo05;
    2.  
    3. public class Person {
    4.     private int money=10_0000_0000;
    5.     public void say() {
    6.         System.out.println("说了一句话");
    7.     }
    8.         public int getMoney(){
    9.             return money;
    10.         }
    11.         public void setMoney(int money){
    12.             this.money=money;
    13.         }
    14.     }

    则子类需使用父类设置的方法使用

    1. package com.oop.demo05;
    2.  
    3. public class Application {
    4.     public static void main(String[] args) {
    5.         Student student=new Student();
    6.         student.say();
    7.         System.out.println(student.getMoney());
    8.     }
    9. }

    IDEA快捷键：

    ctrl+H：查看程序树

    super

    调用父类，如下

    1. package com.oop.demo05;
    2.  
    3. public class Student extends Person {
    4.     private String name="jiawei";
    5.     public void print(){
    6.         System.out.println("Student");
    7.     }
    8.     public void test(String name){
    9.         System.out.println(name);
    10.         System.out.println(this.name);
    11.         System.out.println(super.name);//调用父类
    12.  
    13.     }
    14. }
    1. package com.oop.demo05;
    2.  
    3. public class Person {
    4.     protected String name="weiwei";
    5.     public void print(){
    6.         System.out.println("Person");
    7.     }
    8. }
    1. package com.oop.demo05;
    2. import com.oop.demo05.Person;
    3. import com.oop.demo05.Student;
    4.  
    5. public class Application {
    6.     public static void main(String[] args) {
    7.         Student student=new Student();
    8.         student.test("佳伟");
    9.     }
    10. }

    运行结果如下

    调用父类方法：

    1. package com.oop.demo05;
    2.  
    3. public class Person {
    4.     protected String name="weiwei";
    5.     public void print(){
    6.         System.out.println("Person");
    7.     }
    8. }
    1. package com.oop.demo05;
    2.  
    3. public class Student extends Person {
    4.     private String name="jiawei";
    5.     public void print(){
    6.         System.out.println("Student");
    7.     }
    8.     public void test1(){
    9.         print();//当前类
    10.         this.print();//当前类
    11.         super.print();//调用父类
    12.     }
    13.     public void test(String name){
    14.         System.out.println(name);
    15.         System.out.println(this.name);
    16.         System.out.println(super.name);//调用父类
    17.  
    18.     }
    19.  
    20. }
    1. package com.oop.demo05;
    2. import com.oop.demo05.Person;
    3. import com.oop.demo05.Student;
    4.  
    5. public class Application {
    6.     public static void main(String[] args) {
    7.         Student student=new Student();
    8.         //student.test("佳伟");
    9.         student.test1();
    10.     }
    11. }

    运行结果如下

    私有的东西同样无法被继承

    注意调用父类的构造器必须放在子类构造器的第一行

    super注意点

    1.super调用父类的构造方法，必须在构造方法的第一个

    2.super必须只能出现在子类的方 法或者构造方法中

    3.super和this不能同时调用构造方法

    与this对比

    代表的对象不同

    this：本身调用者这个对象

    super：代表父类对象的应用

    前提

    this：没有继承也可以使用

    super：只能在继承条件才可以使用

    this（）：本类的构造

    super（）：父类的构造

    方法的重写

    静态方法：

    1. package com.oop.demo05;
    2.  
    3. public class A extends B{
    4.     public static void test() {
    5.         System.out.println("A=>test()");
    6.     }
    7. }
    1. package com.oop.demo05;
    2.  
    3. public class A extends B{
    4.     public static void test() {
    5.         System.out.println("A=>test()");
    6.     }
    7. }
    1. package com.oop.demo05;
    2.  
    3. import com.oop.demo05.A;
    4. import com.oop.demo05.B;
    5.  
    6. public class Application {
    7.     public static void main(String[] args) {
    8.         //方法的调用只和左边，定义的数据类型有关
    9.         A a=new A();
    10.         a.test();
    11.         //父类的引用指向了子类
    12.         B b=new A();
    13.         b.test();
    14.  
    15.     }
    16. }

    运行结果如下：

    可以发现方法的调用只和左边，定义的数据类型有关

    非静态方法的重写：

    A与B同时去掉static

    1. package com.oop.demo05;
    2.  
    3. public class B {
    4.     public void test() {
    5.         System.out.println("B=>test()");
    6.     }
    7. }
    1. package com.oop.demo05;
    2.  
    3. public class A extends B{
    4.     public void test() {
    5.         System.out.println("A=>test()");
    6.     }
    7. }
    1. package com.oop.demo05;
    2.  
    3. import com.oop.demo05.A;
    4. import com.oop.demo05.B;
    5.  
    6. public class Application {
    7.     public static void main(String[] args) {
    8.         //方法的调用只和左边，定义的数据类型有关
    9.         A a=new A();
    10.         a.test();
    11.         //父类的引用指向了子类
    12.         B b=new A();//子类重写了父类的方法
    13.         b.test();
    14.  
    15.     }
    16. }

    运行结果如下

    alt+ins快捷键：快速重写方法

    静态的方法与非静态的方法区别很大

    此时子类才重写了父类的方法，才算重写

    重写的关键词只能是public

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

    1.方法名必须相同

    2.参数列表必须相同

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

    4.抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException——>Exception（大）

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

    为什么需要重写：

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

    多态

    1. package com.oop.demo06;
    2.  
    3. public class Application {
    4.     public static void main(String[] args) {
    5.         //一个对象的实际类型是确定的
    6.         //new Student();
    7.         //new Person();
    8.         //可以指向的引用类型就不确定了
    9.         //Student能调用的方法都是自己的或者继承父类的
    10.         Student s1=new Student();
    11.         //Person父类型，可以指向子类，但是不难调用子类独有的方法
    12.         Person s2=new Student();//父类的引用指向子类
    13.         //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
    14.         s2.run();//子类重写了父类的方法，执行子类的方法
    15.         s1.eat();
    16.     }
    17. }

    .

    1. package com.oop.demo06;
    2.  
    3. public class Student extends Person {
    4.     @Override
    5.     public void run() {
    6.         System.out.println("son");
    7.     }
    8.     public void eat(){
    9.         System.out.println("eat");
    10.     }
    11. }
    1. package com.oop.demo06;
    2.  
    3. public class Person {
    4.     public void run(){
    5.         System.out.println("run");
    6.  
    7.     }
    8. }

    运行结果：

    子类能调用的方法都是自己的或者继承父类的

    父类型可以指向子类，但是不能调用子类独有的方法

    可以强制类型转换把s2从父类转换成子类

    ((Student)s2).eat();

    多态注意事项：

    1.多态是方法的多态，属性没有多态

    2.父类和子类有联系 否则有类型转换异常 ClassCastException

    2.存在条件：继承关系，方法需要重写，父类引用指向子类对象

    不能重写的关键词：

    1.static 方法，属于类，它不属于实例

    2.final 常量

    2.private方法

  • 相关阅读:
    golang promethus consul 服务发现
    使用 Python进行量化交易：前向验证分析
    mybatis入门
    阿里云服务器u1和经济型e系列性能差异？哪个比较好？
    Logback日志配置
    基于对立非洲秃鹫优化算法求解单目标优化问题（OAVOA）含Matlab代码
    week 6 贪心
    2024年新版宝塔面板如何安装WordPress网站教程
    TDengine概述以及架构模型
    同花顺_代码解析_技术指标_C
  • 原文地址：https://blog.csdn.net/m0_73770225/article/details/133593107