JavaOOP思想

一：封装
1、为什么需要封装？
封装使数据更安全，便于控制，外部需要关注的内容减，只需要关注公开出来的接口，还可提高代码复用，

2、.封装包括两方面：包括数据封装和功能封装（实现的封装）
（1）隐藏实现：
方法内部实现外部无需关注，只提供给外部访问接口。
隐藏数据：
将属性私有化，对外提供公有的方法（getter和setter）访问私有属性。
另外还可以封装变化。
封装可提高代码复用（重用）：
以下代码复用逐层深入（封装粒度）
1）拷贝/粘贴：代码的复制等
2）封装成方法：多个类都需要调用的方法
3）封装成类：
4）封装成组件
5）框架（实现设计重用，重用层次最高）

（2）.封装的实现：访问修饰符，接口等等。

封装的好处：安全性，复用性，隔离变化。

3、封装用到访问修饰符：
Java中有四种修饰符，访问权限如下：
1、public ：公共成员，完全公开，没有访问限制；
2、private ：私有成员，在类的内部才可以被访问使用；
3、protected ：受保护成员，在本类和派生类中可以被访问；
4、friendly ：默认的，同一个命名空间（同一个包）中可以被访问；
位置 private friendly(默认) protected public
同一个类 是 是 是 是
同一个包的其他类 否 是 是 是
不同包的子类 否 否 是 是
不同包并不是子类 否 否 否 是

如：封装就是将属性私有化,提供共有的方法访问私有属性.做法就是:修改属性的可见性来限制对属性的访问,并为每个属性创建一对取值(getter)方法和赋值(setter)方法,用于对这些属性的访问

4、总结以上实现封装的具体步骤：
（1）修改属性的可见性来限制对属性的访问；
（2）为每个属性创建一对赋值方法和取值方法，用于对这些属性的访问；
（3）在赋值和取值的方法中，加入对属性的存取限制；

5、构造方法
在Java中,任何变量在被使用前都必须先设置初值.Java提供了为类的成员变量赋初值的专门功能:构造方法(constructor)
作用：初始化对象
特点：
(1)构造方法名与类名相同.
　　(2)构造方法不返回任何值,也没有返回类型.
　　(3)每个类可以有零个或多个构造方法.（构造方法可以被重载）
　　(4)构造方法在创建对象时自动执行,一般不能显式地直接调用. 创建对象时由自身调用，还可以通过类反射机制调用
（5）不会被继承
（6）在创建子类时，先调用父类的构造方法
与一般方法的区别：
1.构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。
2.构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。
　　3.不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承。
　　构造方法可以被重载。没有参数的构造方法称为默认构造方法，与一般的方法一样，构造方法可以进行任何活动，但是经常将他设计为进行各种初始化活动，比如初始化对象的属性。

六、方法的重载：
一个类的内部，多个方法名字相同，参数列表不同，与返回值类型无关，这此方法称重载。

二、继承
含义：子类从父类中获得的共同的基本特征和行为。（下一级从上一级所获得的共同的基本特征和行为）

1、为什么需要继承？
考虑到代码的复用性（重用性），如果有一个类是老师类，另外一个类是Java老师类，而Java老师类跟老师类都有公共的基本特征和行为，如果没有继承则需要编写大量重复的代码，有了继承后就可以让Java老师继承老师类的基本特征（属性）和行为（方法），就可以避免这些重复的代码。

2、生活中的继承：
自然界中的各种动物都具有属于动物的基本特征（属性）和行为（方法）。（对象都具有属性和方法）如：兔子和羊是吃草动物，具有吃草动物的基本特征和行为…，这时吃草动物称为父类，兔子和羊称为子类。明显有继承关系。
注意：位于下层的子类会继承上层所有直接或间接父类的特征和行为。

3、继承的好处：
使用继承可提高代码的复用性。

4、符合继承的条件：
（1）在继承关系中，父类更通用，子类更具体。
（2）在继承关系中，父类和子类需要满足is-a 的关系
解释：
（1）在继承关系中，父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。
（2）在继承关系中，比如兔子是吃草动物，满足is-a的关系，兔子和吃草动物能够形成继承关系，但是兔子是老虎吗？不是，因此，兔子和老虎不存在继承关系。

注意：父类也叫超类（superclass）、基类、
  子类也叫派生类

5、了解几种关系：
（1）is-a: 实体与类的关系；―― 是一个，实体是一个类
（2）子类和父类：继承关系；――　是一种，子类是一种父类。
（3）has-a：类与实例的关系；――　有一个，类中有一个实例
（4）关联关系、依赖关系；――　有一种，类中有一种类（如属性的引用）。

6、类与类的关系：6种
继承，依赖，关联，聚合，组合，接口
依赖与关联，优先使用，类中引用另一种类。依赖为方法内引用或作为方法参数，关联为一个类作为另一个类的属性的类型。
聚合与组合，适用整体与部分关系，组合关联性最强。
面向对象通常采用自底向上的思考方式，自底向上的过程为活化，抽象的过程。
自顶向下的思考方式，先有父类（基类，超类），再有子类（衍生类，派生类）。
从顶向下越来越具体，从底向上越来越抽象。
调用父类方法使用super关键字，在普通方法中，调用父类方法可以在任意位置，在构造方法中，必须为第一条语句。子类必须先调用父类构造函数。

6、如何实现继承
一般情况，我们需要注意以下几点：
在java语言,用extends(extend代表扩展的意思)关键字来表示一个类继承了另一个类。
Public class AccpJavaTeacher2 extends AccpTeacher{
}
这段代码表明AccpJavaTeacher2类继承了AccpTeacher类.

注意：Java中不允许多继承
如下面错误例子：
public class Child extends Base1,Base2{}

7、方法重载和重写（继承中用到）
子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法，因此可以重写父类的方法；
（1）方法的重载：
一个类的内部，多个方法名字相同，参数列表不同，与返回值类型无关，这此方法称重载。
（2）方法的重写：
如果在子类中定义的一个方法，其名称、返回类型及参数类表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。

8、super关键字的使用：
1、在子类的构造方法中，通过super关键字调用父类的构造方法；
2、如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。

9、特别注意：
创建对象时，先创建父类对象，再创建子类对象，如果没有显式调用父类的构造方法，将自动调用父类的无参构造方法。
因此：调用父类的构造方法的语句（即super语句）必须是构造方法中的第一条语句。

如下面的常见错误：
class Base{
public String name;
puclic Base(String pName){
name = pName;
}
}

class Child extends Base{
public Child(){
name = “hello”;
super(“Child”);
}
}

10、一切类的祖先－Object
在Java中，所有的Java类都直接或间接地继承了java.lang.Object类。



三、多肽
1、为什么需要多肽？
考虑到代码的扩展性和可维护性（如本来有一个中心老师类，和一个Java老师类，如果还要要扩展一个新类（．NET老师类）时，虽然可以继承，但调用时也会会增加大量的代码量，这样会导致程序的可扩展性和可维护性极差，因此需要多态，也就是调用不同的实例而执行不同的操作。）

2、什么是多态
多态是具有表现多种形态的能力的特征。更术语化的说法是：同一个实现接口，使用不同的实例而执行不同的操作。

理解分析：什么是多态
调用相同的方法，使用不同的实例，执行不同的操作。
如：跑的方法，但各种动物实现跑的方法不同，有用两条腿、有用四条腿……

3、使用多态的好处：
不仅能减少编码的工作量，而且能大大提高代码的可扩展性及可维护性。

4、如何实现多态：
1、子类重写父类的方法。或方法的重载；
2、把父类类型作为参数类型，该父类及其子类对象作为参数传入。
3、运行时，根据实际创建的对象类型动态决定使用哪个方法。（动态绑定）－ 能够实现同一个实现接口，使用不同的实例而执行不同的操作。

理解分析：
方法的重写和重载
（1）方法的重载：
一个类的内部，多个方法名字相同，参数列表不同，与返回值类型无关，这此方法称重载。
方法的重载的作用：
方法重载为了实现多态和完成从业务上看相同的功能。
（2）方法的重写：
如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。

注：
重写：如果父类方法没有抛出异常，则子类方法也不能抛出异常，否则会编译错误。
相反如果父类方法抛出异常，而子类可以不抛出异常，或抛出的异常范围比父类小。

5、多态的体现：
继承、Java接口、方法的重写、重载
四、接口
1、什么是接口
Java中的接口是一系列方法的声明，是一些方法特征的集合，但没有方法的实现。
一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。

interface关键字：定义接口的意思；
implements关键字：继承接口的意思；

2、接口的两种含义：
一、Java接口：Java语言中存在的结构，有特定的语法和结构;
二、接口：一个类所具有的方法的特征集合，是一种逻辑上的抽象。

3、Java方法的特征:
包括：
方法的名字、参数的数目和种类。
不包括：
Java方法的特征没有包括方法的返回类型、参数的名称、抛出来的异常

4、使用接口的需要3点注意：
（1）Java接口不能被实例化。
（2）Java接口中声明的成员自动设置为public，因此Java接口中不能声明私有的成员。
（3）Java接口中不能出现方法体的实现。
（4）实现某个Java接口，就必须实现其中定义的所有方法。

5、为什么需要接口
（1）如果两个类不属于继承关系，但它们却拥有一些共同的特征或行为（方法）这个时候不能使用继承，又要编写大量相同代码，因此这时候就可以用接口来实现，把这些相同的方法封装起来放到接口中，然后就可以继承这个接口，调用时只需把接口类型作为参数类型，继承接口的对象作为参数传入，运行时，Java虚拟机会根据出实际创建的对象类型调用不同的方法实现，这正是体现多态的好处。（如教员类和中心类都有各自的输出详细的方法（detail），detail方法显然是这两个类要实现的同一接口，而教员和中心显然是不同的实例，通过执行各自的detail方法，实现不同的操作，又没有继承关系。）
（2）实现多继承，继承只能单一继承，接口可以实现多继承

例子：
1、没有接口时
（1）教员类的实现代码：
public class AccpTeacher1 {
//输出教员的详细信息
public String detail()
{
return "本人是Accp教员！！！";
}
}

（2）打印机类的实现代码：
public class Printer {
public void print(String content)
{
System.out.println("开始打印：");
System.out.println(content);
}
}

（3）中心类的实现代码：
public class AccpSchool1 {
private Printer printer = new Printer();
//输出中心的详细信息
public String detail()
{
return "这里是accp中心！！！";
}

//使用打印机打印教员信息
public void print(AccpTeacher1 t)
{
printer.print(t.detail());    //t.detail()方法返回的是一个字符串类型
}

//使用打印机打印中心信息
public void print(AccpSchool1 s)
{
printer.print(s.detail());
}

public static void main(String[] args){
AccpSchool1 school = new AccpSchool1();
school.print(new AccpTeacher1());
school.print(school);
}
}

分析：
这时就可以看到在调用输出详细信息的方法detail（）方法时，就需要编写两次相同的代码，这样程序的可维护性和可扩展性差。因此要用上接口。

2、用上接口
(1)//定义一个接口
public interface Introduceable {
//输出教员的详细信息
public String detail();
}

(2)//教员类的实现代码：
public class AccpTeacher2 implements Introduceable {
//输出教员的详细信息
public String detail()
{
return "本人是Accp教员！！！";
}
}

（3）//打印机的实现代码：
public class Printer {
public void print(String content)
{
System.out.println("开始打印：");
System.out.println(content);
}
}

（4）//中心类的实现代码
public class AccpSchool1 implements Introduceable {
private Printer printer = new Printer();
//输出中心的详细信息
public String detail()
{
return "这里是accp中心！！！";
}

//使用中心打印机打印信息  //使用打印机打印教员信息
public void print(Introduceable intro)
{
printer.print(intro.detail());  //t.detail()方法返回的是一个字符串类型
}

public static void main(String[] args){
AccpSchool1 school = new AccpSchool1();
school.print(new AccpTeacher1());
school.print(school);
}
}
这时，print方法接收的参数类型是Introduceable，这样任何实现了Introduceable接口的对象都可以作为参数传递过去，运行时，Java虚拟机会根据实际创建的对象类型调用不同的方法实现，这正是多态给我们的好处。

注意：以上是不同对象之间的使用，如果是同一对象的或就可以使用抽象类来实现。


总结使用接口的步骤：
（1）定义一个Java接口Introduceable，在其中定义的detail方法，但没有具体的实现。
（2）教员类和中心类分别实现了这个Java接口，对detail方法有各自不同的具体实现。
（3）在中心类的打印（print）方法中，接收Java接口作为参数。


经验总结：
使用继承或者Java接口都可以为我们带来多态性的好处，一般情况下，当个类之间符合“is-a”的关系，并且子类可以复用部分父类的代码，我们使用继承关系实现，其他情况下优先选择Java接口。

6、面向接口的编程
（1）什么是面向接口的编程？
开发系统时，主体框架使用接口，接口构成系统的骨架。（这样就可以更换实现接口的类来更换系统的实现，也就是在运行时，Java虚拟机会根据实际创建的对象类型调用不同的方法实现）

（2）面向接口编程的好处
能够提供程序的复用性，增加程序的可维护性、可扩展性。