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”）

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

/**
* 限额对象
* @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);

}
}