Java基础---面向对象

一、理解面向对象

“面向过程”和“面向对象”的区别？

• 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了
• 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为

可以拿生活中的实例来理解面向过程与面向对象，例如五子棋。

• 面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。
• 面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

面向对象的三个特征：

封装（encapsulation） 继承（inheritance） 多态（polymorphism）

二.理解封装

1.定义：

隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。

2.封装途径

• 封装就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。
• 封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。

4. 好处

• 将变化隔离。
• 便于使用。
• 提高重用性。
• 调高安全性。

3.原则

• 把尽可能多的东西藏起来.对外提供简捷的接口。（尽可能声明所有的方法都是public的）
• 把所有的属性藏起来。（声明所有的属性都是private的）

4.成员变量和局部变量：

   成员变量：
            a)成员变量定义在类中，在整个类中都可以被访问。

            b) 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

            c) 成员变量有默认初始化值。

   局部变量：

            a) 局部变量只定义在局部范围内，如：函数内，语句内等。

            b) 局部变量存在于栈内存中。

            c) 作用的范围结束，变量空间会自动释放。

            d) 局部变量没有默认初始化值。

三.理解继承

1.继承

• Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

• 这样类与类之间就存在了继承的关系。子类可以直接访问父类中的非私有的属性和行为。在代码中通过extends关键字表示继承关系。例：

      class Son extends Father{}  //这也是在代码中的书写格式。
  

注意：千万不要为了获取其他类中的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。这种所属关系的表示为is a。

2.继承的特征

• 继承关系是传递的。若类C继承类B，类B继承类A（多继承），则类C既有从类B那里继承下来的属性与方法，也有从类A那里继承下来的属性与方法，还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的，但仍是类C的属性和方法。
• 继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。
• 继承提供了软件复用功能。若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。
• 继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。
• 提供多重继承机制。从理论上说，一个类可以是多个一般类的特殊类，它可以从多个一般类中继承属性与方法，这便是多重继承。Java出于安全性和可靠性的考虑，仅支持单重继承，而通过使用接口机制来实现多重继承。

/*描述：父类方法Father有两个方法：a和b，a方法调用b方法
*子类Son覆盖b方法，
*如果子类Son调用a方法，则显示是什么
*/
public class test1 {

    public static void main(String[] args) {
        Father f = new Father();
        f.a();
        Son s1 = new Son();
        s1.a();
        //这种写法是正确的，因为可以理解为子类就是一个父类
        Father s2 = new Son();
        s2.a();
    }
}

class Father
{
    void a()
    {
    //a方法调用了b方法
        this.b();
    }
    void b()
    {
        System.out.println("This is Father's mehod b!");
    }
}

class Son extends Father
{
//子类中的b方法被覆盖
    void b()
    {
        System.out.println("This is Son's mehod b!");
    }
}

运行结果：

说明：这里的例子说明了类的覆盖，Son类其实是继承了Father类的a方法，那么，b方法被覆盖后，自然调用的是覆盖后的方法。

查缺补漏：

super的使用和this的使用几乎一致，且两者都存在于方法区中。
    this表示本来对象的引用。    
    super表示父类对象的引用。

   1、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
   2、静态只能覆盖静态。
   3、父类中的私有方法不能被重写。

小知识点：

     重载：只看同名函数的参数列表。
     重写：子父类方法要一模一样。

初始化顺序：

• 子类初始化时，会先初始化父类。

为什么子类一定要访问父类中的构造函数？

• 因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。

构造函数结论：

• 子类的所有构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super();当父类中没有空参数的构造函数时，子类必须手动通过supe语句或者this语句形式来指定要访问的构造函数。当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

四.理解多态

多态也叫动态绑定、后期绑定或运行时绑定。
多态有两种表现形式：重载和覆盖
1.覆盖

//多态的体现
public class test1 {

    public static void main(String[] args) {
        Father f = new Father();
        f.a();
        Father s1 = new Son1();
        s1.a();
        Father s2 = new Son2();
        s2.a();
    }
}
//父类
class Father
{
//方法a
    void a()
    {
        this.b();
    }
    //方法b
    void b()
    {
        System.out.println("This is Father's mehod b!");
    }
}
//子类Son1
class Son1 extends Father
{
//方法的覆盖
    void b()
    {
        System.out.println("This is Son1's mehod b!");
    }
}
//子类Son2
class Son2 extends Father
{
//方法的覆盖
    void b()
    {
        System.out.println("This is Son2's mehod b!");
    }
}

说明：b方法被子类Son1和Son2覆盖重写，子类的不同对象的调用体现了不同的使用。
2.重载
标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。

//加法器，实现整数和小数加法，需要重载方法
public class test2 {

    public static void main(String[] args) {
        Math m1 = new Math();
        m1.add(3, 4);
        m1.add(3.412,4.212);
    }
}
class Math
{
//加法方法，需要传int型参数
    void add(int a, int b)
    {
        System.out.println(a+b);
    }
    //加法方法传参为double型
    void add(double a, double b)
    {
        System.out.println(a+b);
    }
}

结果：

方法的重载和类的方法覆盖组成了多态。