JAVA-面向对象程序设计

一.面向对象的基本概念

1.1 对象的基本概念

（1）面向对象： 是一种程序设计方法，是一种编程思想，基于面向过程而言。基本思想是使用对象、类、继承、封装、消息等基本概念类进行程序设计。
（2）对象： 是系统中用来描述客观事物的一个实体，是构成系统的一个基本单位。

1.2 其特点可概括为封装性、继承性、多态性。

（1）封装性：面对对象的核心，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。

（2）继承性：主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。

（3）多态性：是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，他们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。

二.类与对象

2.1 类的基本概念

（1）类: 是引用类型，类的对象存放在堆中。对象是指具体的事务，而类是指一类事务。

（2）类与对象: 类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也称作属性，成员方法用于描述对象的行为，可简称方法。

2.2 类的定义

1. 一个类主要有三个部分组成：
        1.1 构造方法：用来创建对象
        1.2 成员变量：也称属性，用来表示对象的状态
        1.3 方法：对象的行为

2. 如何创建类

  class Person{

         //定义int 类型的变量

         int name;
         //定义speak（）方法
         void speak （）{

         System.out.println(“*****”)
       }
 } //Person 类名，name 是成员变量，speak（）成员方法

3. 类修饰符：
        3.1 public: 这个public关键字声明了类可以在其他类中使用。其缺省时，该类只能被同一个包下的其他类使用。
        3.2 abstract: 声明这个类是一个抽象类，这个类不能被实例化，只用于衍生子类，抽象类中可以包含抽象方法。
        3.3 final： 声明该类不能被继承，不能有子类。

2.3 成员变量和局部变量

（1） 成员变量的声明 ：

[可访问性修饰符] [static] [final] [transient] [volatile] 类型 变量名
上述属性用括号括起来，表示它们都是可选项，其含义分别为：
[可访问性修饰符]： 说明该变量的可访问属性，该修饰符可分为public、protected、package和private。
[static]： 说明该成员变量是一个静态变量（类变量），以区别一般的实例变量。
[final]： 说明是一个常量
[transient]： 声明瞬态变量，瞬态变量不是对象的持久部分。
[volatile] ： 声明一个可能同时被并存运行中的几个线程所控制和修饰的变量

（2）局部变量： 在方法中声明的变量以及方法中参数称为局部变量。局部变量除了作用范围仅适用本方法之外，其余均和成员变量是一致。

（3）作用域： 静态变量 > 成员变量 > 局部变量

2.4 对象

1. 对象的创建
创建对象的一般格式为：

类名 对象名= new 类名（[参数列表]）;

（1）对象声明的一般形式：

类名 对象名；

其中对象声明并不为对象分配内存空间，而只是分配一个引用空间，对象的引用类似于指针，指向对象所在的堆地址，保证对象的安全性。

（2）实例化
实例化是为对象分配内存空间和进行初始化的过程，一般形式为：

对象名 = new 构造方法（）；

2. 对象的使用
对象要通过访问对象变量或调用对象方法来使用。通过 “.” 可以实现对对象自己的变量访问和方法的调用。
（1）访问对象的变量的格式为：

对象名. 成员变量；

（2）调用对象成员方法的格式为：

对象名.方法名（ [参数列表] ）；

三. 成员方法

3.1 构造方法

1. 构造方法：构造方法是类中一个特殊成员，它会在实例化对象时被自动调用。

2. 构造方法的特点：

        ①方法名与类名相同；

        ②在方法名前面没有返回值类型的声明；

        ③在方法中不能使用return语句返回一个值；

class Person{
         //构造方法
        public Person(){
             //无参构造方法
         }
        public Person(int age){
             age = a;   //有参构造方法
        }
        public void speak(){
             System.out.println(“I am” +age+”years old !");
        }
   }
   public  class Example{
        public  static void main (String [] args){
            Person b = new Person(20);  //实例化Person对象
            b.speak();
        }
   }

3. 构造方法的重载：与普通方法一样，方法名相同，只需要参数类型或参数个数不同即可。

一般情况下，构造方法通常会使用public来修饰。

3.2 成员方法的定义

1. 方法定义的介绍：
（1）返回类型： 可以是基本数据类型或引用类型，它是方法体中通过return语句返回值得数据类型，也称该方法的类型。当该方法为无返回值时，需要用void作方法的类型。
（2）方法的参数： 方法名后小括号中的内容称为方法的参数。当小括号里是空的，这样的方法称为无参方法，如果括号里面至少有一个参数参数（称为形式参数，简称形参）
（3）方法体一般由三部分组成：
        ①定义方法所需的变量，定义在方法内部的变量称为局部变量。
        ②完成方法功能的具体实现。
        ③由return语句返回方法的结果。
注意： 方法不允许嵌套定义，即不允许一个方法的定义放在另一个方法的定义中，一个类中可以定义多个方法。

2. 方法的调用
（1）方法调用的语法行式：
通常把调用其他方法的方法称为主调方法，被其他方法调用的方法称为被调方法。

函数名 (实际参数1,实际参数2,…,实际参数n);

（2）形参和实参：
        ①行参：全称“形式参数”是在定义方法名和方法体的时候使用的参数，用于接收调用该方法时传入的实际值。
        ②实参：全称“实际参数”，一个方法在被调用语句中，其参数被称为实际参数，简称实参，也就是在调用方法时传递给该方法的实际值。

3. 方法重载与方法重写
（1）重载： 是指在同一个类中定义了多个同名的方法，但参数的个数或者参数类型不同。（例：println()、Arrays.sort()、构造方法）.
（2）重写： 是指在继承的情况下，子类中定义了和父类中某个方法完全一样的结构，就称为把父类的方法重写了。那么调用时，就直接调用子类的这个方法，而父类方法就不在起作用。
   两者区别： 重写是在继承情况下，是父类子类；而重载是在一个类中，一个类的一个方法多个参数及参数类型不同，重载是多态的一种表现。

五.面向对象特点

面向对象的特点：封装性、继承性、多态性。

5.1 封装性

1. 概念： 封装是把对象的属性和操作（服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现的细节。
2. 访问： 对数据的访问只能通过已定义的接口。
3. 属性私有后无法直接访问：private修饰符修饰的就叫做私有
（1）修改值：可以通过set方法修改。
（2）获取值：可以通过get方法获取。
4. 特点：
（1）减少代码的耦合。
（2）对外隐藏细节，暴露的越少，安全性越好。
（3）规范统一入口，控制数据访问。
5. 修饰符:用来控制一个类，或者类中的成员的访问范围。

5.2 继承性

1. 概念： 继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
2. 特点：
（1）使用extends关键字修饰。
（2）相当于子类把父类的功能复制了一次。
（3）java只支持单继承，继承可以传递，间接实现了多继承。
（4）不能继承父类的构造方法和私有成员，私有方法，即private修饰的
（5）继承多用于功能的修改，子类可以拥有父类的功能的同时，还可以进行功能拓展。
（6）new 子类时，会先调用父类的构造方法创建父类，然后再创建子类。
（7）两种方式：实现继承 extends 、接口继承 implements。
（8）组合优先于继承。

5.3 多态性

1. 概念： 多态是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
2. 实现多态的两种方式：
（1）使用父类作为方法形参实现多态。
（2）使用父类作为方法返回值实现多态。
3. 多态的作用：
（1）可替换性：多态对已存在代码具有可替换性
（2）可扩展性：多态对代码具有可扩展性。增加新的子类不影响已存在类的运行和操作。实际上新加子类更容易获得多态功能。
4. 多态的三个必要条件： 要有继承、要有重写，父类引用指向子类对象
（1）多态的前提是继承，没有父类子类，也就没有多态的情况产生。
（2）要有方法的重写，各自完成各自的业务，从而各个子类体现不同的特征。
（3）父类引用指向子类对象，如 A a= new B（）；