【java系列】面向对象之4大特征|3大特性|5大原则

最新推荐文章于 2024-07-08 17:27:11 发布

WalkerShen

最新推荐文章于 2024-07-08 17:27:11 发布

阅读量858

点赞数 2

分类专栏： java系列文章标签： java

本文链接：https://blog.csdn.net/Think_and_work/article/details/124212561

版权

java系列专栏收录该内容

32 篇文章 0 订阅

订阅专栏

大家好，我是walker
一个从文科自学转行的程序员~
爱好编程，偶尔写写编程文章和生活
欢迎关注公众号【I am Walker】，一块学习编程~

面向对象的4大特征

抽象：

抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。
抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

例如：动物基本上都需要吃，那么就有“吃”这个行为抽象，也有体重，那么就有“体重”这个数据抽象属性了。

封装

封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。
但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。

继承

继承是使用已存在的类的定义作为基础建立新类的技术，

新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。
通过使用继承我们能够非常方便地复用以前的代码。

关于继承如下 3 点请记住：

子类拥有父类非 private 的属性和方法。
子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。

案例解析

父类

package objectOrientedTest;

public class Father {
    
    /**
    * 定义一个private变量和非private变量
    */
    String name;
    private Integer age;


    public void test(){
        System.out.println("i am father");
    }
}

子类

package objectOrientedTest;

public class Son extends Father{


    public static void main(String[] args) {
        Son son = new Son();
        //可以获取非private变量
        System.out.println(son.name);
        //无法获取父类的private变量age
//        System.out.println(son.age);
    }


    /**
    * 重写父类方法
    */
    @Override
    public void test() {
        System.out.println("i am son");
    }

    /**
    * 子类可以扩展自己的方法
    */
    public void myMethod(){
        System.out.println("this is my method");
    }
}

如果获取父类的private方法，则会报错

多态

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，

即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

案例解析

1、定义接口类

package objectOrientedTest.polymorphic;
/**
* 定义接口类
*/
public interface Animal {
    /**
    * 定义吃方法
    */
    void eat();
}

2、定义实现类猫和狗

package objectOrientedTest.polymorphic;


//1、继承Animal接口
public class Cat implements Animal{


    //2、重写eat方法
    @Override
    public void eat() {
        System.out.println("cat eatting");
    }
}




package objectOrientedTest.polymorphic;

public class Dog implements Animal{
    @Override
    public void eat() {
        System.out.println("dog eatting");
    }
}

3、测试

package objectOrientedTest.polymorphic;

public class Test {

    /**
    * 运行时指的是main方法
    */
    public static void main(String[] args) {
        //向上转型
        Animal cat = new Cat();
        cat.eat();
        Animal dog = new Dog();
        dog.eat();
    }
}

输出结果：

cat eatting
dog eatting

解读：
编程时不确定
在编程时，并不知道引用变量发出的方法并不确定，像上面，我们的eat方法有很多个实现类方式，我们并不知道我们要使用哪个对象的eat方法

运行时才能决定
可以看见，我们在运行时的时候，可以实例化狗，也可以实例化猫，然后他们对象都是接口“动物”，这就是多态性了

实现多态的方式

包含两种：分别是重载和重写

方法重载（overload）
实现的是编译时的多态性（也称为前绑定）

package objectOrientedTest.polymorphic;


public class Cat{


    public void eat() {
        System.out.println("cat eatting");
    }

    /**
    * 方法重载，区别在于参数不同
    */
    public void eat(String name){
        System.out.println(name+"cat eatting");
    }
}

方法重写（override）
实现的是运行时的多态性（也称为后绑定）。

案例：
eat方法便是方法重写，一般都有带@override注解

package objectOrientedTest.polymorphic;
/**
* 定义接口类
*/
public interface Animal {
    /**
    * 定义吃方法
    */
    void eat();
}


package objectOrientedTest.polymorphic;


//1、继承Animal接口
public class Cat implements Animal{


    //2、重写eat方法
    @Override
    public void eat() {
        System.out.println("cat eatting");
    }
}