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); } }