面向对象封装、继承

Mortal_ApeBoys

已于 2022-03-30 14:50:41 修改

阅读量614

点赞数 1

文章标签： java

于 2022-03-28 21:46:06 首次发布

本文链接：https://blog.csdn.net/Mortal_ApeBoys/article/details/123806773

版权

Java 变量类型

普通变量直接赋值

引用变量引用了一个内存地址
匿名对象没有引用类型变量指向的对象
优点：使用之后直接从内存中消失不会长期占用内存适用于仅仅偶尔使用的场景
缺点：因为使用之后直接从内存中消失如果频繁使用该对象需要频繁在内存中创建和回收该对象创建和回收过程都要消耗系统资源建议频繁使用对象尽量使用引用类型变量引用
成员变量在类中定义，用来描述对象将要有什么
- 在类的方法中定义，在方法中临时保存数据
  - 成员变量和局部变量的区别
    - a)作用域不同局部变量的作用域仅限于定义它的方法成员变量的作用域在整个类内部都是可见的
    - b)初始值不同成员变量有默认的初始值局部变量没有默认的初始值，必须自行设定初始值
    - c)同名变量不同在同一个方法中，不允许有同名的局部变量在不同的方法中，可以有同名的局部变量
    - d)存储位置不同成员变量是在对象创建以后存在于堆中，对象回收时，成员变量消失局部变量是在方法被调用时存在于栈中，方法调执行结束，从栈中清除
    - e)生命周期不同对象的创建而创建，对象回收时，成员变量消失随着方法的调用被创建，方法执行结束，从栈中清除

在Java语言中，所有的变量在使用前必须声明。

以下列出了一些变量的声明实例。

// 声明三个int型整数：a、 b、c 
int a, b, c;    
// 声明三个整数并赋予初值 
int d = 3, e = 4, f = 5; 
// 声明并初始化 z
byte z = 22;     
 // 声明并初始化字符串 s
String s = "runoob";  
 // 声明了双精度浮点型变量 pi
double pi = 3.14159; 
 // 声明变量 x 的值是字符 'x'。
char x = 'x';

Java语言支持的变量类型有：

类变量：独立于方法之外的变量，用 static 修饰。
实例变量(成员变量)：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

实例

public class Variable{ 
    // 类变量
    static int allClicks=0;    
     // 实例变量
    String str="hello world";  
    public void method(){         
        // 局部变量
        int i =0;  
             
    } 
}

Java 局部变量

局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

实例 1

在以下实例中age是一个局部变量。定义在pupAge()方法中，它的作用域就限制在这个方法中。

 public class Test{    
    public void pupAge(){      
        int age = 0;      
        age = age + 7;      
        System.out.println("小狗的年龄是: " + age);   
    }      
    public static void main(String[] args){      
        Test test = new Test();      
        test.pupAge();   
    } 
}

以上实例编译运行结果如下:

小狗的年龄是: 7

实例 2

在下面的例子中 age 变量没有初始化，所以在编译时会出错：

public class Test{    
    public void pupAge(){      
        int age;      
        age = age + 7;      
        System.out.println("小狗的年龄是 : " + age);   
    }      
    public static void main(String[] args){      
        Test test = new Test();      
        test.pupAge();   
    } 
}

以上实例编译运行结果如下:

//variable number might not have been initialized
// 变量号可能尚未初始化
age = age + 7;
         ^
1 error

实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。
数值型变量的默认值是0，
布尔型变量的默认值是false，
引用类型变量的默认值是null。
变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
成员变量可以通过类的实例化对象名点方法名的方式调用静态方法也可以通过类的实例化对象名点方法名的方式调用非静态方法

实例

public class Employee{   
    // 这个实例变量对子类可见   
    public String name;   
    // 私有变量，仅在该类可见   
    private double salary;   
    //在构造器中对name赋值   
    public Employee (String empName){      
        name = empName;   
    }  
    //设定salary的值   
    public void setSalary(double empSal){      
        salary = empSal;   
    }     
    // 打印信息   
    public void printEmp(){      
        System.out.println("名字 : " + name );     
        System.out.println("薪水 : " + salary);   
    }    
    public static void main(String[] args){      
        Employee empOne = new Employee("RUNOOB");      
        empOne.setSalary(1000.0);      
        empOne.printEmp();  
    } 
}

以上实例编译运行结果如下:

$ javac Employee.java 
$ java Employee
名字 : RUNOOB
薪水 : 1000.0

类变量（静态变量）

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
默认值和实例变量相似。
数值型变量默认值是 0，
布尔型默认值是 false，
引用类型默认值是 null。
变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
静态方法可以通过类名点方法名的方式调用但是不能通过类名点方法名的方式调用非静态方法
类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

实例：

public class Employee {    
    //salary是静态的私有变量    
    private static double salary;    
    // DEPARTMENT是一个常量    
    public static final String DEPARTMENT = "开发人员";    
    public static void main(String[] args){    
        salary = 10000;        
        System.out.println(DEPARTMENT+"平均工资:"+salary);   
    } 
}

以上实例编译运行结果如下:

开发人员平均工资:10000.0

注意：如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT。

访问修饰符

类别	关键字	说明
访问修饰符	public	公共的
访问修饰符	protected	受保护的
访问修饰符	default	默认的
访问修饰符	private	私有的

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
public :对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
this 方法的调用者谁调用我我就是谁
this 在此处的含义是调用本类中的成员变量

1、Java 封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

1. 良好的封装能够减少耦合。
1. 类内部的结构可以自由修改。
1. 可以对成员变量进行更精确的控制。
1. 隐藏信息，实现细节。

实现Java封装的步骤

修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {    
    private String name;    
    private int age; 
}

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

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

this关键字指向的是当前对象的引用

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

实例

java封装类的例子：


public class Person {
    /**
     * 昵称
     */
    private String nickName;
    /**
     * 性别 1 代表男性 0 代表女性
     */
    private int gender;
    /**
     * 年龄
     */
    private int age;

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
    //  this关键字指向的是当前对象的引用
    //  指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）
        this.nickName = nickName;
    }

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

}

以上实例中public方法是外部类访问该类成员变量的入口。

通常情况下，这些方法被称为getter和setter方法。

因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

通过如下的例子说明Person类的变量怎样被访问：


public class Person02Test02 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person person = new Person();
        person.setAge(1);
        person.setGender(18);
        person.setNickName("小白");
        System.out.println("名字 -->> " + person.getAge());
        System.out.println("\n性别 -->> " + (person.getGender() == 1 ? "精神小伙" : "扒蒜老妹儿"));
//      Incompatible operand types String and int
//      操作数类型String和int不兼容
//      System.out.println("名字" + person.getNickName() 
//        + "性别" + person.getGender() == 1 ? "精神小伙" : "扒蒜老妹儿");
        System.out.println("名字 -->> " + person.getNickName() + 
                           "\n性别 -->> " + (person.getGender() == 1 ? "精神小伙" : "扒蒜老妹儿"));

    }

}

以上代码编译运行结果如下:

名字 -->> 1

性别 -->> 扒蒜老妹儿
名字 -->> 小白
性别 -->> 扒蒜老妹儿

构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。

不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。

一旦你定义了自己的构造方法，默认构造方法就会失效。

有参构造方法

定义一个person抽象类，含有构造方法



/**
 * person类 含有有参构造方法
 */
public class Person {
    /**
     * 昵称
     */
    private String nickname;
    /**
     * 年龄
     */
    private int age;
    /**
     * 性别
     */
    private int gender;

    /**
     * 全参构造方法
     * 
     * @param nickname 昵称
     * @param age      年龄
     * @param gender   性别
     */
    public Person(String nickname, int age, int gender) {
        this.nickname = nickname;
        this.age = age;
        this.gender = gender;

    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public int getAge() {
        return age;
    }

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

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }

}

定义一个person测试类，实现person类的属性和构造方法


public class PersonTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person person = new Person("小白", 18, 1);
        System.out.println("昵称\t" + person.getNickname() + 
                "\n年龄\t" + person.getAge() + "\n性别\t" + (person.getGender() == 1 ?"精神小伙" : "扒蒜老妹儿") );

    }

}

上面代码输出结构

昵称  小白
年龄  18
性别  精神小伙

无参构造方法

无论什么情况下一定要手写一个无参构造

2、Java 继承

继承的概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

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

生活中的继承：

兔子和羊属于食草动物类，狮子和豹属于食肉动物类。

食草动物和食肉动物又是属于动物类。

所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

类的继承格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

类的继承格式

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

为什么需要继承

接下来我们通过实例来说明这个需求。

开发动物类，其中动物分别为企鹅以及老鼠，要求如下：

企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
老鼠：属性（姓名，id），方法（吃，睡，自我介绍）

企鹅类：

public class Penguin {     
    private String name;     
    private int id;     
    public Penguin(String myName, int  myid) {         
        name = myName;         
        id = myid;     
    }     
    public void eat(){         
        System.out.println(name+"正在吃");     
    }    
    public void sleep(){        
        System.out.println(name+"正在睡");    
    }    
    public void introduction() {         
        System.out.println("大家好！我是"         
                           + id + "号" + name + ".");     
    }  
}

老鼠类：

public class Mouse {     
    private String name;     
    private int id;     
    public Mouse(String myName, int  myid) {         
        name = myName;         
        id = myid;     
    }     
    public void eat(){         
        System.out.println(name+"正在吃");     
    }    
    public void sleep(){        
        System.out.println(name+"正在睡");    
    }    
    public void introduction() {         
        System.out.println("大家好！我是"         
                           + id + "号" + name + ".");     
    }  
}

从这两段代码可以看出来，代码存在重复了，导致后果就是代码量大且臃肿，而且维护性不高(维护性主要是后期需要修改的时候，就需要修改很多的代码，容易出错)，所以要从根本上解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成一个父类：

公共父类：

public class Animal {     
    private String name;      
    private int id;     
    public Animal(String myName, int myid) {         
        name = myName;         
        id = myid;    
    }     
    public void eat(){         
        System.out.println(name+"正在吃");     
    }    
    public void sleep(){        
        System.out.println(name+"正在睡");    
    }    
    public void introduction() {         
        System.out.println("大家好！我是"         
                           + id + "号" + name + ".");     
    }  
}

这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码）继承之后的代码：

企鹅类：

public class Penguin extends Animal {     
    public Penguin(String myName, int myid) {         
        super(myName, myid);     
    }  
}

老鼠类：

public class Mouse extends Animal {     
    public Mouse(String myName, int myid) {         
        super(myName, myid);     
    }  
}

继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。

继承的特性

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

extends 关键字

public class Animal {     
    private String name;       
    private int id;     
    public Animal(String myName, int myid) {         
        //初始化属性值    
    }     
    public void eat() {  
        //吃东西方法的具体实现  
    }     
    public void sleep() { 
        //睡觉方法的具体实现  
    }  
}   
public class Penguin  extends  Animal{  }

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

implements 关键字

public interface A {    
    public void eat();    
    public void sleep(); 
}  
public interface B {    
    public void show(); 
}  
public class C implements A,B { }

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

实例

class Animal {  
    void eat() {    
        System.out.println("animal : eat");  
    } 
}  
class Dog extends Animal {  
    void eat() {    
        System.out.println("dog : eat"); 
    }  
    void eatTest() {    
        this.eat();   
        // this 调用自己的方法    
        super.eat();  
        // super 调用父类方法  
    } 
}  
public class Test {  
    public static void main(String[] args) {    
        Animal a = new Animal();    
        a.eat();    
        Dog d = new Dog();    
        d.eatTest();  
    } 
}

输出结果为：

animal : eat
dog : eat
animal : eat

final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

final 含义为 "最终的"。

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：

声明类：
```
final class 类名 {
    //类体
}
```

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){
    //方法体
}

注： final 定义的类，其中的属性、方法不是 final 的。

构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

实例

class SuperClass {  
    private int n;  
    SuperClass(){    
        System.out.println("SuperClass()");  
    }  
    SuperClass(int n) {    
        System.out.println("SuperClass(int n)");    
        this.n = n;  
    } 
} 
// SubClass 类继承 
class SubClass extends SuperClass{  
    private int n;    
    SubClass(){ 
        // 自动调用父类的无参数构造器    
        System.out.println("SubClass"); 
    }      
    public SubClass(int n){     
        super(300);  
        // 调用父类中带有参数的构造器    
        System.out.println("SubClass(int n):"+n);    
        this.n = n;  
    } 
} 
// SubClass2 类继承 
class SubClass2 extends SuperClass{  
    private int n;    
    SubClass2(){    
        super(300);  
        // 调用父类中带有参数的构造器    
        System.out.println("SubClass2");  
    }      
    public SubClass2(int n){ 
        // 自动调用父类的无参数构造器    
        System.out.println("SubClass2(int n):"+n);    
        this.n = n;  
    } 
} 
public class TestSuperSub{  
    public static void main (String args[]){    
        System.out.println("------SubClass 类继承------");    
        SubClass sc1 = new SubClass();    
        SubClass sc2 = new SubClass(100);     
        System.out.println("------SubClass2 类继承------");    
        SubClass2 sc3 = new SubClass2();    
        SubClass2 sc4 = new SubClass2(200);   
    } 
}

输出结果为：

------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200