Java面向对象的三大特性-白红宇的个人博客

Java面向对象的三大特性

发布日期：2022-02-14 16:09:29 浏览次数：22 分类：技术文章

本文共 5591 字，大约阅读时间需要 18 分钟。

封装
- 概念：将一组逻辑相关的属性或方法封装在类中，通过访问权限修饰符来隐藏内部细节，公开访问的接口的技术称之为类的封装技术。
- 封装的好处：
  - 隐藏内部实现细节；保护其不受外部影响
  - 方便内部修改
  - 降低外部使用的复杂度
  - 良好的封装可降低耦合
- 属性的封装方式
  - 用private修饰属性
  - 提供set方法和get方法来分别为属性设置值或者取得属性值
  - setter、getter方法是public（公开的），命名遵守setter属性名与getter属性名的规则，boolean的get方法使用is属性名
```
private String name;private int age;private boolean result;public void setName(String name){    this.name=name;}public String getName(){    return name;}public void setAge(int age) {    this.age=age;}public int getAge() {    return age;}public void setResult(boolean result) {    this.result=result;}public boolean isResult(){    return true;}
```
- 构造器的封装（单例模式使用私有构造器）
```
public class InstanceTon {    private static InstanceTon instanceTon = new InstanceTon();    private InstanceTon(){}    public static InstanceTon getInstance(){        return instanceTon;    }}
```
  　　当然方法也能封装，使用访问权限修饰符来实现

继承

概念：一个类的定义基于另一个已存在的类（即子类基于父类），可实现代码的重用，子类能够获得已有类（父类）的属性和方法（非私有），并能扩展其它属性或方法的能力。

使用关键字extends实现继承

继承与构造器

子类继承父类，父类的构造器先执行，子类的构造器后执行

默认情况下，子类会调用父类的默认无参构造器

子类调用父类的非默认构造器，需使用super关键字并且指定正确的参数类型

super调用父类的构造器必须在子类的构造器第一行

public class Animal {
             public Animal() {        System.out.println("构造Animal");    }    public Animal(int index){        System.out.println("构造Animal@");    }    public Animal(int x,int y){        System.out.println("构造Animal@@");    }}public class Fish extends Animal {
             public Fish() {        System.out.println("构造Fish");       }    public Fish(int index){        super(12,23);        System.out.println("构造Fish&");    }}public class SeaFish extends Fish {
             public SeaFish(){        System.out.println("构造SeaFish");    }    public SeaFish(int index){        super(23);        System.out.println("构造SeaFish%");    }    public static void main(String[] args) {        SeaFish seaFish = new SeaFish(23);        System.out.println("======**======");    }}

SeaFish(int index)–>Fish(int index)–>Animal(int x,int y)。子类有义务先去执行父类构造方法则会先去构造父类，super关键字指明了使用父类的那个构造器。输出结果如下：

构造Animal@@构造Fish&构造SeaFish%======**======

继承中构成方法重写的条件
- 方法名相同
- 形参相同
- 同返回值类型
- 子类方法的访问权限控制符不能缩小

public class Shape {
         public void draw() {        System.out.println("正在画图形");    }    public double area(double x) {        System.out.println("计算面积");        return x;    }}public class Crcle extends Shape {
         private double radius;    private double area;    public void draw() {        System.out.println("正在画圆");    }    public double area(double x) {        area = x*x*Math.PI;        return area;    }}public class App {
         public static void main(String[] args) {        Crcle crcle = new Crcle();        crcle.draw();        Square square = new Square();        square.draw();    }}

final修饰符
- final修饰类，则该类不可被继承；
- final修饰属性，该属性不可变；
- final修饰方法，该方法不可被重写；

接口可以继承多个接口，类是单继承的

多态

面向对象三大特性之一；

含义：对外一种表现形式，对内多种具体实现；

典型用法：

//父类变量指向子类实现Parent = new Child();//接口的变量指向实现类的实现 Interfacei = new Implementation();

体现

方法重载

方法重写

多态参数（依赖关系”use-a”）

方法的参数为父类或者接口时，可传入父类的子类或者接口的实现类

/*** 限额对象* @author Administrator**/public class Quota {
               private double amount;    private String  type;    public double getAmount() {        return amount;    }    public void setAmount(double amount) {        this.amount = amount;    }    public String getType() {        return type;    }    public void setType(String type) {        this.type = type;    }}/*** 限额加载器* @author Administrator**/public interface QuotaLoader {
               Quota load(String userId);}/*** 业务限额加载器* @author Administrator**/public class BusinessQuotaLoader implements QuotaLoader {
               @Override    public Quota load(String userId) {        return null;    }}/*** 央行政策性限额* @author Administrator**/public class PolicyQuotaLoader implements QuotaLoader{
               @Override    public Quota load(String userId) {        return null;    }}public class CalcService {
               private static final QuotaLoader[] QUOTA_LOADERS = {
          new PolicyQuotaLoader(),new BusinessQuotaLoader()};    public static void main(String[] args) {        List
           
             quotas = new ArrayList<>();        for(QuotaLoader ql : QUOTA_LOADERS){            Quota q = ql.load("xxxx");            quotas.add(q);        }        //quotas排序，得到最小的限额      }}

扩展性强

转换

隐式转换：把子类转换为父类；

强制转换（类型兼容）：用（类型）强制转换（需注意编译期类型与运行期类型）；

//父类强转子类（子类名）父类实例    //运行报错Animal不能强转为Cat    Animal animal = new Animal();    Cat cat = (Cat)animal;    //能转    Animal anim = new Cat();    Cat c = (Cat)anim;    //把子类转为父类，隐式转换（自动转换）    //运行报错Dog不能强转为Cat    Animal anima = new Dog();    Cat ca = (Cat)anima;    //编译报错    Dog dog = new Dog();    //Cat cat2 = (Cat)dog;

如果强制转换的两个类型没有父子关系，编译正常，运行报错；

运行期类型与编译期类型（运用多态时需注意）
- Animal animal = new Cat();
- 运行期Cat，编译期Animal；
- 同名属性，与类型名相同；

多态环境下的属性和方法
- 静态方法，与类型名相同；
- 成员方法，由于重写，会先去执行子类方法；
- 同名属性，与类型名相同；

public class Animal {
         public String age = "3";    public void bark(){        System.out.println("动物叫");    }    public static void sf(){        System.out.println("父类静态方法");    }}public class Cat extends Animal {
         public int age = 5;    public void bark(){        System.out.println("喵~喵~");    }    public void catchMice(){        System.out.println("抓老鼠");    }    public static void sf(){        System.out.println("子类静态方法");    }}public class Dog extends Animal {
         public void bark(){        System.out.println("汪汪");    }}public class App2 {
         public static void main(String[] args) {        Animal a = new Cat();        //对于成员方法调用，因为方法覆盖的问题，导致运行期调用的是子类的方法        a.bark();        //对于同名的静态方法调用，声明为何类型则调用该类型的方法               a.sf();        //对于同名的属性，实际为声明类型的属性                System.out.println(a.age);    }}

转载地址：https://blog.csdn.net/qq_29593573/article/details/72886283 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！

上一篇：sql 关联表分隔符拼接字段查询

下一篇：JavaSE 异常处理

发表评论

关于作者

喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！

-- 愿君每日到此一游！

发表评论

最新留言

关于作者

推荐文章