Java面向对象的三大特性

• 封装

  • 概念：将一组逻辑相关的属性或方法封装在类中，通过访问权限修饰符来隐藏内部细节，公开访问的接口的技术称之为类的封装技术。
  • 封装的好处：
    
    • 隐藏内部实现细节；保护其不受外部影响
    • 方便内部修改
    • 降低外部使用的复杂度
    • 良好的封装可降低耦合

  • 属性的封装方式

    • 用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<Quota> 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);    }}