Java基础之面向对象的三大特征

面向对象的三大特征

1. 封装：提高程序的安全性 (数据的准确性)
2. 继承：提高代码的复用性 (重复使用性)
3. 多态：提高程序的可扩展性和可维护性

学Java，看这一套就够了

一、封装

• 隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，提高程序的安全性
• 隐藏实现的细节，仅仅需要关注具体的功能
• 方法的抽取，仅仅需要关注方法的功能 忽略方法实现的细节
• 项目的模块化设计 层次的划分

1、对类的属性进行隐藏

使用private关键字 修饰类的成员变量

private修饰的成员变量 仅仅可以在当前类中直接使用

Public class Person{
  private String name;
  private String gender;
  private int age;
}

2、给每个属性提供公有的get(获取)和set(赋值)方法

public class Person {
    private String name;
    private String gender ;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    //定义一个方法 返回当前对象的name属性值
    public String getName(){
        return name;
    }
    public void setGender(String gender){
        //如果性别是男或者女  那么 正常赋值
        if(gender.equals("男")|| gender.equals("女")){
            this.gender=gender;
        }else{
            //如果性别不是男也不是女 那么给一个默认值为 男
            this.gender="男";
        }
    }
    //定义一个方法 返回当前对象的gender属性
    public String getGender(){
        return gender;
    }
    public void setAge(int age) {
        if (age > 0 && age < 100) {
            this.age = age;
        }
    }
    //定义一个方法  返回当前对象对的age属性值
    public int getAge(){
        return age;
    }
    public void showInfo(){
        System.out.println(name+gender+age);
    }
}

测试代码：

public class TestPerson {
    public static void main(String[] args) {
        //获得Person对象
        Person p=new Person();
        p.setName("旋涡刘能");
        p.setGender("男");
        p.setAge(56);
        p.showInfo();
        //仅仅需要查看人的属性  怎么办?
        System.out.println(p.getAge());
        System.out.println(p.getGender());
        System.out.println(p.getName());
    }
}

总结：

1. 属性全部隐藏 对象内部的特点不让外界知道 我们仅仅需要关注对象的功能即可 内部的实现 使用了哪些成员 统统不用考虑
2. 数据的安全性和和规范性更高

二、继承

java中由已知类创建新类的一种机制，新类拥有已知类的属性和方法，同时，还可以有自己独有的属性和方法

减少相同代码的反复编写，提高代码的复用性，减少编码量，提高程序的可维护度

继承是怎么来的？

是对N多个类的抽像，根据N多个类，抽取出像的部分，归纳为父类，被抽取的类，称为子类

1、在Java中如何实现继承？

在java中使用extends (扩展)实现继承，说明子类是父类的扩展

新类(子类) extends 已知类(父类)

一个父类可以有多个子类，但是一个子类只能有一个直接父类

【例】

1、先准备父类

public class Car {
    String color;
    String brand;
    String type;
    public void start(){
        System.out.println("一辆"+color+"颜色的"+brand+type+"正在启动");
    }
    public void speedUp(){
        System.out.println("一辆"+color+"颜色的"+brand+type+"正在加速");
    }
    public void speedDown(){
        System.out.println("一辆"+color+"颜色的"+brand+type+"正在减速");
    }
}

2、准备子类

Audi

public class Audi extends Car {
    // 定速巡航
    public void speedKeeping(){
        System.out.println("一辆"+color+"颜色的"+brand+type+"启动了定速巡航");
    }
}

BMW

public class BMW extends Car {
    //温度调节
    public void temperatureRegulation(){
        System.out.println("一辆"+color+"颜色的"+brand+type+"启动了温度调节");
    }
}

测试代码：

public class TestExtends {
    public static void main(String[] args) {
        Audi au =new Audi();
        au.brand="奥迪";
        au.color="黑";
        au.type="TT";
        au.start();
        au.speedUp();
        au.speedKeeping();
        au.speedDown();
      
        BMW b =new BMW();
        b.brand="宝马";
        b.color="白";
        b.type="X5";
        b.start();
        b.speedUp();
        b.temperatureRegulation();
        b.speedDown();
    }
}

2、super关键字

1、当子类中重写父类中同名的属性

那么在子类中父类的同名的属性被隐藏了

如果在子类中想继续使用父类隐藏的属性 那么要使用super关键字调用父类属性

2、子类对父类同名方法的重新定义叫做方法的重写

子类重写父类方法之后 父类的方法就默认隐藏了

如果子类想继续使用父类中被隐藏的同名方法 那么要使用super关键字调用

public class Test1 {
    public static void main(String[] args) {
        S s =new S();
        s.showName();
        s.viewName();
    }
}
//父类F
class F{
    String name="父类name属性的值";
    public void viewName(){
        System.out.println(name);
    }
}
//子类S
class S extends F{
    String name="子类name属性的值";
    public void showName(){
        System.out.println(name);
        System.out.println(super.name);
    }
    //子类重写父类的viewName()方法
    public void viewName(){
        System.out.println(name);
        super.viewName();
    }
}

三、多态

• 一种事物可以有多种表现形态
• 父类作为方法参数 所有的子类对象都可以作为实参
• 父类作为方法的返回值 所有的子类对象都可以返回

子类父类相互转换：

1. 子类对象可以声明成父类对象
2. 子类拥父类的属性和方法
3. 父类不能声明成子类对象
4. 父类对象可以通过强制转换声明成子类对象 可以通过编译 但是运行的时候会出现 ClassCastException
5. 当父类对象原本就是由子类对象声明而成的 那么强制转换回子类 就不会报错
6. 子类声明成父类对象时 调用方法会执行子类的方法
7. 编译时 认为是父类 只能调用到父类中声明的方法
8. 执行时 认为是子类 占用子类内存 执行子类方法

public class Test1 {
    public static void main(String[] args) {
       
        F f =new S();
        f.methodA();
        //f.methodB();报错
        System.out.println(f instanceof  F);
        System.out.println(f instanceof  S);
        
    }
}
class F{
    public void methodA(){
        System.out.println("父类中的方法");
    }
}
class S extends F{
    public void methodA(){
        System.out.println("子类中重写父类的方法");
    }
    public void methodB(){
        System.out.println("子类中独有的方法");
    }
}

本文就先写到这里了，你弄懂面向对象的三大特征了吗？

Java零基础入门全套教程