【Java】06 面向对象基本特征

Demo_Null

发布于 2020-09-28 11:03:03

4560

发布于 2020-09-28 11:03:03

文章被收录于专栏：Java 学习

面向对象的三大基本特征：封装、继承、多态。

一、封装

1.1 概述

1.1.1 什么是封装

封装（Encapsulation）是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。采用封装的思想保证了类内部数据结构的完整性，使用该类的用户不能轻易地直接操作此数据结构，只能操作类允许公开的数据。这样就避免了外部操作对内部数据的影响，提高了程序的可维护性。

1.1.2 访问控制符

	同一个类中	同一个包中	不同包的子类	不同包的无关类
public	✓	✓	✓	✓
protected	✓	✓	✓
default	✓	✓
private	✓

public（公共访问权限）：这是一个最宽松的访问控制级别，如果一个成员（包括成员变量、方法和构造器等）或者一个外部类使用 public 访问控制符修饰，那么这个成员或外部类就可以被所有类访问，不管访问类和被访问类是否处于同一个包中，是否具有父子继承关系。 protected（子类访问权限）：如果一个成员（包括成员变量、方法和构造器等）使用 protected 访问控制符修饰，那么这个成员既可以被同一个包中的其他类访问，也可以被不同包中的子类访问。在通常情况下，如果使用 protected 来修饰一个方法，通常是希望其子类来重写这个方法。 default（包访问权限）：如果类里的一个成员（包括成员变量、方法和构造器等）或者一个外部类不使用任何访问控制符修饰，就称它是包访问权限的，default 访问控制的成员或外部类可以被相同包下的其他类访问。 private（当前类访问权限）：如果类里的一个成员（包括成员变量、方法和构造器等）使用private访问控制符来修饰，则这个成员只能在当前类的内部被访问。很显然，这个访问控制符用于修饰成员变量最合适，使用它来修饰成员变量就可以把成员变量隐藏在该类的内部。

1.1.3 this 关键字

public class Test {

	int a = 3;

    public static void main(String[] args) {
        test(5);
    }
    
    public void test(int a) {
        System.out.println(a); // 5
    }
}

运行上述代码可以看到输出的是 5 ，而不是 3。这就是 Java 的就近原则，如果想要输出 5 则需要借助 this 关键字，this 代表所在类当前对象的引用，即谁调用就代表谁。

1.1.4 final 关键字

final 修饰类，被修饰的类不能被继承、修饰方法，被修饰的方法不能被重写、修饰变量，被修饰的变量不能重新赋值。

// 修饰类
final class 类名{ ··· }
// 修饰方法
final 返回值类型 方法名( 参数列表 ) { ··· }
// 修饰变量
final 数据类型 变量名;

1.2 类的封装

1.2.1 封装步骤

（1）私有化 使用 private 关键字修饰成员变量，使其私有化。 （2）暴露方法 提供 setXXX()/getXXX()方法来设置和获取成员变量。 （3）this 在成员方法中局部变量和成员变量重名是就需要使用 this 了。

1.2.2 示例

public class Add {
    // 私有成员变量
    private int a;
    private int b;

    // 提供公共访问方法
    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    //成员方法
    public int add() {
        int sum = a + b;
        return sum;
    }
}

1.3 构造方法

1.3.1 什么是构造方法

在类中除了成员方法之外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。

1.3.2 语法

public 构造方法名( 参数列表 ) {
    方法体;
}

1.3.3 注意

构造方法名与类名必须一致。有参数的构造方法称为有参构造，没有参数的构造方法称为空参构造。构造方法可以重载，但无论如何，Java类至少包含一个构造器。若没有写任何构造方法，JVM 会自动帮你写一个空参构造。

1.3.4 示例

public class Test {
    // 成员变量
    private int a;
    private int b;

    // 空参构造
    public Test() {
    }
	
	// 有参构造
    public Test(int a, int b) {
        this.a = a;
        this.b = b;
    }

    //set/get方法
    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }
}

二、继承

2.1 概述

2.1.1 什么是继承

继承的基本思想是基于某个父类的扩展，并制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加原来父类所不具备的属性和方法，或者直接重写父类中的某些方法。

2.1.2 extends 关键字

在 Java 中，让一个类继承另一个类需要使用 extends 关键字，子类在继承父类的同时，也继承了父类中的属性和方法。

2.1.3 super 关键字

子类可以重写父类中的方法，但是再重写之后想要调用父类中的方法需要借助 super 关键字，super 关键字代表父类对象。

2.2 类的继承

2.2.1 语法

public class 父类 { ··· }
public class 子类 extends 父类 { ··· }

2.2.2 注意

（1）成员变量： 不重名没有影响，使用谁就是谁。重名则 new 谁就是谁的 ( 开发中一般不会重名 )，此时如果要使用父类的非私有成员变量与需要使用 super.父类成员变量名。 （2）成员方法： 不重名没有影响，使用那个方法就是那个方法。重名则为子类重写（覆盖）父类方法，声明不变，重新实现。 （3）构造方法： 构造方法名与类名一致，所以不能被继承。构造方法是用来初始化成员变量的，所以子类初始化的过程中，父类必须先于子类初始化。即调用构造方法时，一定先调用父类的构造方法。子类的空参构造中会默认写有 super()，表示调用父类的构造方法，父类的成员变量初始化之后才可以给子类使用。 （4）其他注意事项： 子类覆盖父类方法是，必须保证子类方法权限大于父类。子类覆盖父类方法要保证，权限、返回值、方法名、参数列表一模一样。类的继承只支持单继承，不支持多继承所有类的父类都是 Object

2.2.3 示例

// 父类，手机类
public class Phone {
    // 成员变量
    private String brand;
    private String price;

    // 构造方法
    public Phone() {
    }

    public Phone(String brand, String price) {
        this.brand = brand;
        this.price = price;
    }

    // 成员方法
    public void call() {
        System.out.print("打电话！");
    }

    public void send() {
        System.out.println("发短信！");
    }

    public void show() {
        System.out.println(brand + "牌手机，售价" + price);
    }
}

// 子类，小米手机
public class MiPhone extends Phone{
    // 构造方法
    public MiPhone() {
        // 默认有 super();
    }

    public MiPhone(String brand, String price) {
        super("mi 10 pro","3999");
    }

    //重写父类方法
    @Override
    public void call() {
        super.call();   //调用父类原有 call() 方法

		// 子类新增功能
        System.out.print("显示姓名! ");
        System.out.print("显示号码! ");
    }

    //子类特有方法
    public void inter() {
        System.out.println("上网!");
    }
}

//测试类
public class test {
    public static void main(String[] args) {
        //new 对象
        MiPhone mp = new MiPhone();

        //调用父类方法
        mp.send();		// 发短信！
        
        //调用子类重写方法
        mp.call();			// 打电话！显示姓名! 显示号码!

        //调用子类特有方法
       	mp.inter();			// 上网!
    }
}

三、多态

3.1 抽象

3.1.1 概述

（1）抽象方法：使用 abstract 修饰的没有方法体的方法称为抽象方法。（2）抽象类：包含抽象方法的类称为抽象类。

3.1.2 语法

修饰符 class abstract 类名 {
	修饰符 abstract 返回值类型 方法名(); 
}

3.1.3 注意

抽象类不能创建对象。抽象类中可以有构造方法，是提供给子类创建对象时初始化父类成员变量使用。子类需重写父类所有的抽象方法，除非子类也是抽象类。抽象方法一定要在抽象类中，抽象类不一定要有抽象方法。最终必须有子类是实现父类所有的抽象方法。

3.1.4 示例

//父类，抽象类
public abstract class Fu {
    public abstract void num();
}

//子类，实现父类
public class Zi extends Fu{
    public void num() {
        System.out.println("子类");
    }
}

3.2 接口

接口是Java中一种引用类型，是方法的集合。接口中主要封装了方法，包含抽象方法(JDK 1.7 之前)，默认方法、静态方法(JDK 8)，私有方法(JDK 9)。

3.2.1 语法

public interface 接口名{
        //抽象方法(JDK 1.7 之前)
        //默认方法(JDK 8)
        //静态方法(JDK 8)
        //私有方法(JDK 9)
}

3.2.2 接口的使用

（1）抽象方法(☆☆☆☆☆)

//与抽象类相似
public interface Inter{
    public abstract void method();
}

（2）默认方法

//主要用于升级接口，防止以前的实现类报错，新创建的实现类可以覆盖默认方法。
//接口中有多个默认方法是，实现类都可以继承使用。
public interface Inter{
    public default void method(){
        System.out.println("run···");
    }
}

（3）静态方法

//直接使用接口已经完成的现成功能。
public interface Inter{
    public static void method(){
        System.out.println("run···");
    }
}

（4）私有方法

//用于抽取接口中相同的代码块
//1.私有方法：只有默认方法可以调用
public default void methodA(){
    method();
}
public default void methodB(){
    method();
}
private void method() {
    System.out.println("runA···");
    System.out.println("runB···");
}

//2.私有静态方法：默认方法和静态方法都可以调用
public default void methodA(){
    method();
}
public static void methodB(){
    method();
}
private static void method() {
    System.out.println("runA···");
    System.out.println("runB···");
}

注意： 接口不能直接 new 调用接口原本的默认方法：接口名.super.默认方法名(); 静态方法属于接口，只能通过：接口名.静态方法名() 调用。

3.2.3 接口的多实现

// 继承并实现
public class 类名 extends 抽象类 implement 接口名{
    //方法体
}  
// 多实现
public class 类名 [ extends Object ] implement 接口名1， 接口名2，··· ，接口名n {
    //方法体
}
// 多继承
public interface 类名 extends 接口名1， 接口名2，··· ，接口名n {
    //方法体
}

注意： 如果抽象方法有重名，则只需要重写一次。如果默认方法有重名，则必须重写。那个接口在前则那个接口优先级高。

3.3 多态

Java 引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态。

3.3.1 语法

// 父类引用指向子类对象
父类 变量名 = new 子类();

// 接口引用指向实现类对象
接口 变量名 = new 实现类();

3.3.2 注意

多态调用成员变量时：编译看左，运行看左。即：父类没有则不能使用多态调用成员方法时：编译看左，运行看右。即：父类没有则不能通过编译

3.3.3 类型转换

向上转型（默认）

父类 类名 = new 子类();

为什么要想上转型：父类类型作为方法形式参数，传递子类对象，更能体现多态的扩展性与便利性 向下转型（强制）

子类 类名1 = ( 子类 )  类名2;

为什么要向下转型：使用多态方式无法调用子类特有方法。向下转型需要注意只有以前是这个类才能转。 instanceof 关键字 用来判断向下转型时是否属于该类。例如: 动物A instanceof 猫；

3.3.4 示例

//父类
public abstract class Phone {
    public abstract void price();
}

//子类，联想
public class LenovoPhone extends Phone{
   public void newPrice() {
       System.out.println("3999");
   }
}

//子类，华为
public class HonorPhone extends Phone{
   public void newPrice() {
       System.out.println("6999");
   }
}

//测试类
public class Test{
    public static void main(String[] arg) {
        //父类引用指向子类对象
        Phone phone = new LenovoPhone();

        method(phone);

    }

    //判断属于那个子类
    public void method(phone phone) {
        if(phone instanceof LenovoPhone) {
            //向下强转
            LenovoPhone lp = (LenovoPhone)phone;
            //调用联想手机类独有方法
            lp.newPrice();
            System.out.println("这是联想手机");
        }
        if(phone instanceof HonorPhone) {
            //向下强转
            HonorPhone hp = (HonorPhone)phone;
            //调用华为手机类独有方法
            hp.newPrice();
            System.out.println("这是华为手机");
        }
    }
}

四、内部类

4.1 成员内部类

4.1.1 语法

//外部类
class 类名 {
    //内部类
    class 类名 {
        ···
    }
}

4.1.2 注意

成员内部类定义在类中方法外内部类可以直接访问外部类的成员，包括私有成员外部类要想访问内部类的成员必须先创建内部类对象

4.2 局部内部类

4.2.1 语法

// 外部类
class 类名 {
	// 方法
    修饰符 返回值类型 方法名( 参数列表 ) {
        class 类名 {    //局部内部类
            ···
        }
    }
}

4.2.2 注意

局部内部类定义在方法中局部内部内在堆中，局部变量在栈中，方法出栈后，局部变量消失，局部内部类等待 JVM 回收

4.3 匿名内部类 ☆☆☆☆☆

4.3.1 语法

父类或接口名 对象名 = new 父类或接口 {
    //方法重写
    @Override
}

4.3.2 注意

【等号左边】是多态，父类引用指向子类对象。【等号右边】定义并创建父类或接口的类对象。匿名内部类是省略了【实现类/子类】名称，匿名对现象是省略了【对象名】。

4.3.3 示例

//接口
public interface Inter {
    //抽象方法
    public abstract void method();
}

//测试类
public class InterAnonymous {
    public static void main(String[] ards) {
        //匿名内部类
        new Inter {
            public void method() {
                System.out.println("使用了匿名内部类和匿名对象");
            }
        }.method();
    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2020/04/12 ，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法

面向对象编程

java

打包

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度