1. 继承
在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，
并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，
这是类之间的一种关系，提高了软件的可重用性和可扩展性。
使用继承
编写父类
class pet {
// 公共属性和方法
}
编写子类，继承父类
class dog extends pet {
// 子类特有的属性和方法
}
class cat extends pet {
// 子类特有的属性和方法
}
继承的特性
单根性
只能继承一个类，不能多重继承
传递性
从父类继承来的元素，可以被子类继承
子类访问父类成员
使用super 关键字
访问父类构造方法
// 构造器
public dog() {
// 访问父类构造方法
// super();
super(" 二哈 ",2);
}
访问父类构造属性
super.name;
访问父类方法
super.print();
不可被继承的资源
不可继承被私有化的属性和方法
构造方法
作用
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
注意
Java 只支持单继承，不允许多重继承。
即一个子类只能有一个父类。
但一个父类可以派生出多个子类
方法的重写(override)
在子类中可以根据需要对从父类中继承来的方法进行改造。
在程序执行时，子类的方法将覆盖父类的方法。
要求
重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。
重写方法不能使用比被重写方法更严格的访问权限。
重写和被重写的方法须同时为static 的，或同时为非 static 的。
子类方法抛出的异常不能大于父类被重写方法的异常。
注意
如果父类的一个方法定义成private 访问权限，在子类中有相同的方法，则不叫重写，因为子类无法访问到
package mytest;
public class A{
private void privateFunc() {
System.out.println("A privateFunc");
}
void defaultFunc() {
System.out.println("A defaultFunc");
}
protected void protectedFunc() {
System.out.println("A protectedFunc");
}
public void publicFunc() {
System.out.println("A publicFunc");
}
}
package mytest;
public class B extends A{
// 不是重写，而是定义了另外一个函数，重写的前提是有访问权限
private void privateFunc() {
System.out.println("B privateFunc");
}
// 重写
void defaultFunc() {
System.out.println("B defaultFunc");
}
// 重写
protected void protectedFunc() {
System.out.println("B protectedFunc");
}
// 重写
public void publicFunc() {
System.out.println("B publicFunc");
}
}
package mytest;
public class Test {
public static void main(String[] args) {
A a = new B();
B b = new B();
// a.privateFunc(); // 只能在类内部调用
a.defaultFunc();
a.protectedFunc();
a.publicFunc();
// b.privateFunc(); // 只能在类内部调用
b.defaultFunc();
b.protectedFunc();
b.publicFunc();
}
}
输出：
B defaultFunc
B protectedFunc
B publicFunc
B defaultFunc
B protectedFunc
B publicFunc
2. 封装
封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的
变动影响。在面向对象的编程语言中，对象是封装的基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象
的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法
可以直接访问同一个对象中的属性。通常情况下，只要记住让外汇返佣http://www.fx61.com/变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成 私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了， 就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数 据放在同一个类中。
例如，人要在黑板上画圆，这一共涉及三个对象：人、黑板、圆，画圆的方法要分配给哪个对象呢？由于画圆需要使用到圆心和半径，
圆心和半径显然是圆的属性，如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径
这两个属性，人以后只是调用圆的画圆方法、表示给圆发给消息而已，画圆这个方法不应该分配在人这个对象上，这就是面向对象的
封装性，即将对象封装成一个高度自治和相对封闭的个体，对象状态（属性）由这个对象自己的行为（方法）来读取和改变。一个更便于
理解的例子就是，司机将火车刹住了，刹车的动作是分配给司机，还是分配给火车，显然，应该分配给火车，因为司机自身是不可能有那
么大的力气将一个火车给停下来的，只有火车自己才能完成这一动作，火车需要调用内部的离合器和刹车片等多个器件协作才能完成刹车
这个动作，司机刹车的过程只是给火车发了一个消息，通知火车要执行刹车动作而已。
import java.util.Date;
public class Emp {
private String name;
private int age;
private String gender;
private int salary;
private Date hiredate;
public Emp() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public Date getHiredate() {
return hiredate;
}
public void setHiredate(Date hiredate) {
this.hiredate = hiredate;
}
}
封装的好处
隐藏类的实现细节；
只能通过规定方法访问数据；
方便加入控制语句；
方便修改实现；
封装的步骤
修改属性可见性 – 设为 private
public class pet {
// 创建属性并修改可见性
private String name;
private int age;
}
创建get/set 方法 – 用于属性读写
// 创建 get 方法
public String getName() {
return name;
}
// 创建 set 方法
public void setName(String name) {
this.name = name;
}
在get/set 方法中加入控制语句 – 对属性进行合法判断
public void setAge(int age) {
// 加入控制语句
if(age > 0 && age < 100){
this.age = age;
}
}
3. 多态性
多态性是指允许不同类的对象对同一消息作出响应。
实现多态的3 个条件： 1 、必须有子类继承父类。 2 、必须有方法覆盖。 3 、必须有父类的引用指向子类。
多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，
很好的解决了应用程序函数同名问题。
使用多态实现思路
编写父类
class Pet {
// 吃东西
public void eat(){
}
}
编写子类，子类重写父类方法
class Dog extends Pet {
// 重写父类方法
public void eat(){
System.out.println(" 吃骨头 ");
}
}
运行时，使用父类类型，子类对象
class cat extends Pet {
Pet pet = new Dog();
}
只能调用父类有的方法
编译看左，运行看右
Pet pet = new Dog();
4. 抽象
抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，
并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，
你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person 类，如下：
class Person{
String name;
int age;
}
人本来是很复杂的事物，有很多方面，但因为当前系统只需要了解人的姓名和年龄，所以上面定义的类中只包含姓名和年龄这两个属性，
这就是一种抽像，使用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解就是不要用显微镜去看一个事物的所有方面，
这样涉及的内容就太多了，而是要善于划分问题的边界，当前系统需要什么，就只考虑什么。
抽象包括两个方面，一是数据抽象，二是过程抽象。
数据抽象——就是用代码的形式表示现时世界中一类事物的特性，就是针对对象的属性。比如建立一个鸟这样的类，鸟都有以下属性：
一对翅膀、两只脚、羽毛等。抽象出来的类都是鸟的属性，或者成员变量。
过程抽象——就是用代码形式表示现实世界中事物的一系列行为，就是针对对象的行为特征。比如鸟会飞、会叫等。抽象出来的类一般都是鸟的方法。
