面向对象（封装与继承）

标签：static关键字   div   细节   return   耦合   data   方法参数   内部数据   优点   

封装：

封装的概念：将代码的细节隐藏起来，然后对外界提供可以使用的公共方法。

在现实生活中，一台电饭煲，一台榨汁机都是封装的体先，榨汁机只需要我们加入材料按下按钮，就能为我们榨一杯果汁，我们不知道榨汁机内部的运行细节，但是它给了我们想要的结果。同样，在编程的世界里，也进行了代码之间的封装，比如我们的数组工具类Arrays就是一个封装，它可以将无序的数组排列成有序的，可以将查找数组某个数的位置，这些功能就像榨汁机一样给我们带来了遍历。

工具类Arrays的实践：

public static void main(String[] args) {
        int arr [] = {89,21,-23,00,24, 8 ,-89,27};  //定义数组arr
        Arrays.sort(arr);                           //调用工具类Arrays来排序arr数组
        System.out.println(Arrays.toString(arr));   //调用toString 来打印数组arr
        
    }

Arrays 的封装让我们操作数组简单方便

封装基本使用：

• 使用 private 关键字来修饰类的成员（成员变量和成员方法）以及类。

• 对需要访问的成员变量，提供对应的一对 getXxx方法 、setXxx 方法。

• private修饰的成员方法，只允许本类中的其他方法调用；

• private修饰的类，只能作为内部类使用（内部类后续详解）。

成员变量和成员方法：

public class Dome02 {
    /*
     * 首先，成员变量的封装 将成员变量修饰为private这样就只能本类访问，其他的类就访问不了 但是如果不给其他类访问又无意义了
     */
    
    /* 所以我们可以提供公共的方法来使其他类来访问 */
    private String name;
    private int age;
//    创建get set方法   set赋值，get获取值；
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
    
    //    封装方法 如果不想其他类直接访问到这个类同样可以使用  private  仅供本类使用
    private void name() {
        
    }
    
}

封装类：

public class Dome03 {  
     private class User{  //在一个类中定义一个私有的User类
         private int a;
     }
     public static void main(String[] args) {
            /* 如果想要访问内部类 首先要访问外部的公共类，在去访问内部私有类 */
          Dome03 dome03 = new Dome03();
          User user = dome03.new User();  
          user.a =1;
    }
}

封装的优点：

• 良好的封装能减少代码的耦合；
• 安全性高，不用担心外部篡改内部数据
• 灵活度高，提高了代码的复用性
• 能够更好，更精准的控制修改代码、

访问修饰符：

 注：default 在修饰时什么都不用写，默认就为 default

例如  void name(){   } 就是一个default修饰的方法，不用写default这个关键字 ，否则会报错

继承：

继承简述：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承语法：

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

继承后的特点：

• 成员变量 ：子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字  super.属性名
• 成员方法：如果子类出现与父类重名方法，但是方法参数不同，这种情况属于方法重载； 如果子类出现与父类重名方法，同时方法参数也相同，这种情况叫做方法重写Override。

子类与父类的创造空间：

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

继承的特点:

1、Java只支持单继承，不支持多继承

//一个类只能有一个父类，不可以有多个父类。 
class C extends A{} //ok 
?
class C extends A，B... //error

2、Java支持多层继承(继承体系)

class A{} 
?
class B extends A{} 
?
class C extends B{}

3、所有的类都直接或者间接继承了Object类，Object类是所有类的父类。

final关键字：

Java提供有一个final关键字，中文意思是最终、终极的意思，在Java中代表不可变更的意思。final关键字可以用来修饰类、成员变量、成员方法。

概念：

• final修饰类：表示最终类，也就是此类不能被继承；
• final修饰变量：表示常量，也就是一个变量的值始终如一，无法变更；
• final修饰方法：表示最终方法，也就是此方法不能被重写。

代码：

// 1、final类
public final class Hello {
    。。。
}

// 2、final方法、变量
public class Hello {
    private final int n=1;
    public final void run() {
        System.out.println("hello world");
    }
}

注意点：

• 被final修饰的成员变量，必须进行初始化赋值，且值不能变更，否则编译出错；
• 被final修饰的成员变量，通常会结合final和static关键字一起使用，表示一个全局的静态常量，常量名用大写；
• 被final修饰的局部变量，不能使用static修饰，同时可以不用先初始化赋值，使用时进行一次赋值即可，后续也不能变更；
• final修饰基本数据类型，表示该基本数据类型的值一旦在初始化后便不能发生变化；
• final修饰引用数据类型，则在对其初始化之后便不能再改变引用地址了，但该引用所指向的对象的内容是可以发生变化的。

个人学习，内容简略

面向对象（封装与继承）

标签：static关键字   div   细节   return   耦合   data   方法参数   内部数据   优点   

原文地址：https://www.cnblogs.com/2979100039-qq-con/p/13411956.html