一、封装(encapsulation)
成都创新互联公司成立于2013年，是专业互联网技术服务公司，拥有项目网站建设、成都网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元从化做网站,已为上家服务,为从化各地企业和个人服务,联系电话:028-86922220
封装性就是把类（对象）的属性和行为结合成一个独立的相同单位，并尽可能隐蔽类（对象）的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。封装的特性使得类（对象）以外的部分不能随意存取类（对象）的内部数据（属性），保证了程序和数据不受外部干扰且不被误用。
这个怎么理解呢？首先来看一个列子。
已知一个类Animal，该类的属性和方法如下表所示：
属性
说明
方法
说明
String name
名称
Animal()
无参构造函数，为属性设置初始值
Int age
年龄
Animal(String name,int age)
有参构造函数，为属性设置变量值
根据该类的定义，编写一个程序，输出该类的初始值以及通过变量设置的初始值，程序代码如下
public class AnimalDemo{
public static void main(Stringargs[]){
Animal a=new Animal();
Animal b=new Animal("cat",5);
System.out.println(a.name+"is "+a.age+" years old");
System.out.println(b.name+"is "+b.age+" years old");
}
}
程序执行结果：
Dog is 3 years old
cat is 5 years old
由此可以知道，类Animal的无参构造函数为name属性赋值为“Dog”，为age属性赋值为“3”。因此，可以写出类Animal的代码如下：
class Animal {
String name;
int age;
Animal(){
name="Dog";
age=3;
}
Animal(Stringname,int age){
this.name=name;
this.age=age;
}
}
实际上这就是上一篇文章中的例子，那么封装在这里的含义如下：
l 类本身就实现了封装功能，此处类Animal定义了两个属性，两个构造函数，其只属于Animal类。
l 通过访问修饰符来限制对类的属性和方法的访问，各修饰符含义如下：
Private:成员变量和方法只能在类内被访问，具有类可见性
默认： 成员变量和方法只能被同一个包里的类访问，具有包可见性。
Protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问
Public：可以被同一个项目中所有的类访问，具有项目可见性，这是最大的访问权限
l 只能通过类本身定义的方法来对该类所实例化的对象进行数据的访问和处理。比如想对实例化的对象添加其它的一个方法和属性是不可能的。这就体现的类的封装性。这里也可以理解一下为什么类被称之为模板或者蓝图。
二、继承
1、继承是面向对象的三大特征之一，也是实现代码复用的重要手段。Java的继承具有单继承的特点，即只能继承自一个父类，每个子类只有一个直接父类，但是其父类又可以继承于另一个类，从而实现了子类可以间接继承多个父类，但其本质上划分仍然是一个父类和子类的关系。
2、Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类称为父类(有的也称其为基类、超类)，父类和子类的关系，是一种一般和特殊的关系。就像是水果和苹果的关系，苹果继承了水果，苹果是水果的子类，水果是苹果的父类，则苹果是一种特殊的水果。
3、Java使用extends作为继承的关键字，extends关键字在英文是扩展的意思，而不是继承。为什么国内把extends翻译成继承呢？除了与历史原因有关外，把extends翻译成为继承也是有其道理的：子类扩展父类，将可以获得父类的全部属性和方法，这与汉语中得继承（子辈从父辈那里获得一笔财富成为继承）具有很好的类似性。
值得指出的是：Java的子类不能获得父类的构造器。
创建子类一般形式如下：
class 类名 extends 父类名{
子类体
}
4、子类与父类的变量、方法关系
子类可以继承父类的所有特性，但其可见性，由父类成员变量、方法的修饰符决定。对于被private修饰的类成员变量或方法，其子类是不可见的，也即不可访问；对于定义为默认访问（没有修饰符修饰）的类成员变量或方法，只有与父类同处于一个包中的子类可以访问；对于定义为public或protected 的类成员变量或方法，所有子类都可以访问。
子类中可以声明与父类同名的成员变量，这时父类的成员变量就被隐藏起来了，在子类中直接访问到的是子类中定义的成员变量。
子类中也可以声明与父类相同的成员方法，包括返回值类型、方法名、形式参数都应保持一致，称为方法的覆盖。
如果在子类中需要访问父类中定义的同名成员变量或方法，需要用的关键字super。Java中通过super来实现对被隐藏或被覆盖的父类成员的访问。super 的使用有三种情况：
l 访问父类被隐藏的成员变量和成员方法；
super.成员变量名;
l 调用父类中被覆盖的方法，如：
super.成员方法名([参数列]);
l 调用父类的构造函数，如：
super([参数列表]);
super( )只能在子类的构造函数中出现，并且永远都是位于子类构造函数中的第一条语句。
举例：
class BaseClass{
public double weight;
public void info(){
System.out.println("我的体重是"+weight+"千克");
}
}
public class ExtendsDemo001 extends BaseClass{
public static void main(String[]args) {
//创建ExtendsDemo001对象
ExtendsDemo001 ed = new ExtendsDemo001();
//ExtendsDemo001本身没有weight属性，但是ExtendsDemo001的父类有weight属性，也可以访问ExtendsDemo001对象的属性
ed.weight = 56;
//调用ExtendsDemo001对象的info()方法
ed.info();
}
}
举例二：
class Animal {
String name="animal";
int age;
void move(){
System.out.println("animalmove");
}
}
classDog extends Animal{
String name="dog"; //隐藏了父类的name属性;
float weight; //子类新增成员变量
void move(){ //覆盖了父类的方法move()
super.move(); //用super调用父类的方法
System.out.println("Dog Move");
}
}
publicclass InheritDemo{
public static void main(String args[]){
Dog d=new Dog();
d.age=5;
d.weight=6;
System.out.println(d.name+" is"+d.age+" years old");
System.out.println("weight:"+d.weight);
d.move();
}
}
程序运行结果：
dog is5 years old
weight:6.0
animalmove
DogMove
举例三：
classSuperClass {
SuperClass() {
System.out.println("调用父类无参构造函数");
}
SuperClass(int n) {
System.out.println("调用父类有参构造函数：" + n );
}
}
classSubClass extends SuperClass{
SubClass(int n) {
System.out.println("调用子类有参构造函数：" + n );
}
SubClass(){
super(200);
System.out.println("调用子类无参构造函数");
}
}
publicclass InheritDemo2{
public static void main(String arg[]) {
SubClass s1 = new SubClass();
SubClass s2 = new SubClass(100);
}
}
程序运行结果：
调用父类有参构造函数：200
调用子类无参构造函数
调用父类无参构造函数
调用子类有参构造函数：100
请自行分析程序运行的结果，体会继承的用法。
封装和继承同时可以的
封装：主要实现了隐藏细节，对用户提供访问接口，无需关心方法的具体实现。
继承：很好的实现了代码的复用，提高了编程效率。
多态：程序的可扩展性及可维护性增强。
继承就是一种由已有的类创建新类的机制，是指在已有类的基础上扩展功能。继承中分为子类和父类
类可以有两种重要的成员：成员变量和方法。子类的成员中有一部分是子类自己声明定义的，另一部分是从它的父类继承的。
1.所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法操作.
2. 所谓子类继承父类的方法作为子类中的一个方法，就象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法调用。
(1) Java只支持单一继承，也就是只有一个父类，利用extends 关键字继承；
class A{ }
class B{ }
class C extends A,B{ // 错误的，因为同时继承了两个父类 }
(2)Java中允许多层继承
class A{ }
class B extends A{ }
class C extends B{ }
//这就是一个封装类，封装的思想就是属性私有化，提供可以访问设置属性的共有方法
public class Person {
private String name;
private int age;
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 void talk(){
System.out.println("一个人在说话");
}
}
//学生继承了人类，因为学生也是人（废话）
public class Student extends Person {
//班级
private String theClass;
//地址
private String address;
public String getTheClass() {
return theClass;
}
public void setTheClass(String theClass) {
this.theClass = theClass;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public void talk() {
System.out.println("一个学生在说话");
}
public static void main(String[] args){
//多态也就是父类引用指向子类对象
Person student = new Student();
student.talk();
}
}