Java面向对象三-CSDN博客

本文链接：https://blog.csdn.net/weixin_74389517/article/details/137206426

本文详细介绍了Java中的访问权限修饰符（private、default、protected、public），展示了如何在类中使用它们，并探讨了封装、继承、多态的概念，以实例说明了方法重载、方法覆写和接口实现的多态性。

摘要由CSDN通过智能技术生成

Java中的访问权限修饰符主要用来限制对类、变量、方法和构造器的访问。以下是Java中的四种访问权限修饰符：

private：这是访问级别最严格的修饰符。一个被声明为private的变量、方法或构造器只能被同一个类中的其他方法访问。
默认（无修饰符）：也被称为包级私有。如果一个类、变量、方法或构造器没有访问修饰符，那么它只能被同一个包中的其他类访问。
protected：这个修饰符的访问级别比包级私有要高。被声明为protected的变量、方法或构造器可以被同一个包中的其他类访问，也可以被不同包中的子类访问。
public：这是访问级别最高的修饰符。一个被声明为public的类、变量、方法或构造器可以被任何其他类访问。

以下是如何在Java中使用这些访问修饰符的示例：

// 示例：使用不同的访问修饰符  
public class OuterClass {  
    private int privateVar = 1; // 只能被OuterClass访问  
    int defaultVar = 2; // 可以被OuterClass和同一个包中的其他类访问  
    protected int protectedVar = 3; // 可以被OuterClass、同一个包中的其他类以及子类访问  
    public int publicVar = 4; // 可以被任何类访问  
  
    private void privateMethod() {  
        System.out.println("This is a private method.");  
    }  
  
    void defaultMethod() {  
        System.out.println("This is a default method.");  
    }  
  
    protected void protectedMethod() {  
        System.out.println("This is a protected method.");  
    }  
  
    public void publicMethod() {  
        System.out.println("This is a public method.");  
    }  
}

封装：
封装含义：
1.包装，例如讲一下常用的功能进行抽取，定义成一个方法；
2.面向对象特征中的封装：隐藏（控制类中成员对外可见性）

封装案例1：将类中属性私有化
封装案例2：将某些方法私有化
java设计模式（模板，固定套路）
解决一类问题的固定方式。
单例模式：单个实例，在系统中，想让某个类只能创建一个对象。

成员变量和局部变量：
位置：
成员变量：在类中定义局部变量：在方法中定义
权限修饰不同：
成员变量：可使用权限修饰符；
局部变量：不可使用权限修饰符；
初始化不同：
成员变量：非静态--在创建后，由构造方法初始化；
静态--类加载时初始化；
局部变量：在方法中声明，声明后需自己进行初始化；
生命周期不同：生（创建）销毁
成员变量：非静态--创建对象对象被回收
静态--类加载类被卸载
局部变量：当方法被调用当方法执行结束
在内存中位置不同：
成员变量：非静态--与对象在堆空间存储
静态--与类信息在方法区中存储
局部变量：与方法在栈中存储
继承：
子继承父：儿子就可以拥有父亲的功能
面向对象也引入继承思想
猫和狗都有名字，年龄吃东西等属性和行为；
可将这些共性和行为抽取，就不需要将这些共性给每个类中重复地定义；

创建动物类：名字，年龄，吃的东西
创建两个类继承动物类：
例如：猫狗猪等等，在子类中定义他们特有的特征。
继承的优点：
减少代码冗余，提高代码的复用性；
提高程序功能的扩展性；
继承细节：
子类不能直接访问父类中私有的成员或方法；（子类是拥有父类的私有成员）
多种类可以叠加继承：A类->B类->C类
子类继承父类后拥有父类所有的实例变量和方法。
：有时父类方法中的实现不满足子类所需实现，
可重写将父类方法在子类中进行重写（在子类中对父类方法进行重写）

Java中的多态（Polymorphism）是面向对象编程的三大基本特性之一，它表示一个接口可以有多种不同的实现方式或一个引用类型可以指向多种实际类型。多态允许我们使用父类型的引用指向子类型的对象，并且可以调用子类覆写（override）的父类方法。这种机制增强了代码的灵活性和可重用性。

Java多态的实现方式主要有三种：方法重载（Overloading）、方法覆写（Overriding）和接口实现。

方法重载（Overloading）

方法重载发生在同一个类中，通过方法的参数列表（参数类型、参数个数或参数顺序）不同来区分不同的方法。虽然这不是严格意义上的多态，但它提供了一种方式让同一个名字的方法可以执行不同的操作。

class OverloadingExample {  
    void show(int num) {  
        System.out.println("int: " + num);  
    }  
      
    void show(double num) {  
        System.out.println("double: " + num);  
    }  
      
    void show(String str) {  
        System.out.println("String: " + str);  
    }  
}

方法重写（Overriding）

方法覆写发生在父类和子类之间，子类可以覆写父类中定义的非私有、非静态、非final和非构造器方法。当使用父类类型的引用指向子类对象时，调用该方法会执行子类中的实现

class Animal {  
    void makeSound() {  
        System.out.println("The animal makes a sound");  
    }  
}  
  
class Dog extends Animal {  
    @Override  
    void makeSound() {  
        System.out.println("The dog barks");  
    }  
}  
  
public class Test {  
    public static void main(String[] args) {  
        Animal myDog = new Dog(); // 父类引用指向子类对象  
        myDog.makeSound(); // 输出 "The dog barks"  
    }  
}

接口实现

接口定义了一组方法的规范，任何实现该接口的类都必须提供这些方法的具体实现。当使用接口类型的引用来引用实现该接口的类的对象时，可以实现多态。

interface Shape {  
    void draw();  
}  
  
class Circle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Circle::draw() method.");  
    }  
}  
  
class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Rectangle::draw() method.");  
    }  
}  
  
public class TestShapes {  
    public static void main(String args[]) {  
        Shape shape1 = new Circle(); // 接口引用指向Circle对象  
        Shape shape2 = new Rectangle(); // 接口引用指向Rectangle对象  
          
        shape1.draw(); // 输出 "Inside Circle::draw() method."  
        shape2.draw(); // 输出 "Inside Rectangle::draw() method."  
    }  
}

在上述例子中，Shape 接口定义了一个 draw 方法，Circle 和 Rectangle 类分别实现了这个接口。当我们创建 Shape 类型的引用并指向 Circle 或 Rectangle 对象时，就可以调用 draw 方法，并且会根据实际对象的类型执行不同的操作。