面向对象

面向对象

面向对象是对面向过程的编程方式进行改进的一种思想；面向对象时一种设计程序、部署程序结构的思路，其核心宗旨是将程序中的各个功能细化；面向对象的特征：封装、继承、多态。

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

*  人为抽象的一种编程模型

*  将问题分解成一个一个独立的小问题，通过解决每个小问题，来解决大问题

面向对象的思想

 

如果将对象比作汽车，那么类就是汽车的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计。

 

  类

  对象（实例）

  引用

  构造方法

  this

  方法重载

  

  继承

  super

  方法重写

  

  多态

  向上转型

  向下转型

  instanceof

  

  抽象类

  

  final

  static

  访问控制符

  

  接口

  

  内部类

 

类

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 类比成“图纸”

  * 对事物、算法、逻辑、概念的抽象  

  * 把相关的属性数据和逻辑运算方法进行封装，封装成一个类，形成一个独立的程序组件

创建类

--------------------------------------------------------------------------

语法格式：

[< 修饰符>]class < 类名>{

[<属性声明>]

[<构造器声明>]

[<方法声明>]

}

说明：修饰符public：类可以被任意访问

  类的正文要用{  }括起来

举例：

public class  Person{

     private int age ;             //声明私有变量age

     public void showAge(int i) { //声明方法showAge

  age = i;

     }

}

声明属性

-------------------------------------------------------------------------------

语法格式：

[<修饰符>]  类型  <属性名> [=初值] ;

说明：修饰符 private: 该属性只能由该类的方法访问。

  修饰符 public: 该属性可以被该类以外的方法访问。

  类型：任何基本类型，如int、boolean或任何类。

举例：

public class Person{

   private int age;             //声明private变量age

    public String name = “Lila”; //声明public变量name

}

*）属性有时也称为：数据成员(数据)，成员变量(变量)

 

声明方法：

----------------------------------------------------------------------------------------

语法格式：

  <修饰符> <返回类型> <方法名>([<参数表>]) {

           [< 语句>]

}

说明： 修饰符：public,private,protected 等。

返回类型：return语句传递返回值。没有返回值：void。

举例：

public class Person{

     private int age;

     public int getAge()  { return age; } //声明方法getAge

     public void setAge(int i) {          //声明方法setAge

   age = i;        //将参数i的值赋给类的成员变量age

     }

}

*）方法有时也称为：成员函数(函数)

 

对象（实例）

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 类比成“产品”

  * 每个对象占用独立的内存空间，保存各自独立的属性值

  * 可以独立的控制一个对象，执行指定方法的代码

 

 

 

对象的创建和使用

-----------------------------------------------------------------

*）使用 new +构造方法创建一个新的对象；

*）使用 “对象名.对象成员”的方式访问对象成员（包括属性和方法）；

举例：

public class Car {

String brand;

int highSpeed;

public Car() {

}

public void go() {

System.out.println(

 brand+"汽车以最高时速"+

 highSpeed+"前进");

}

public void stop() {

System.out.println(

brand+"汽车停止");

}

}

 

右边测试代码结果为：

 

public class Test1 {

public static void main(String[] args) {

/*

 * 1. 新建两个Car对象赋给a，b

 * 2. 为 a 的两个属性赋值

 * 3. 为 b 的两个属性赋值

 * 4. 分别调用 a,b 的go()方法

 *    让汽车前进

 * 5. 分别调用 a,b的stop()方法

 *    让汽车停止

 */

Car a = new Car();

Car b = new Car();

a.brand = "别摸我";

a.highSpeed = 250;

b.brand = "保+洁";

b.highSpeed = 30;

a.go();

b.go();

a.stop();

b.stop();

}

}

 

各种类型成员变量的默认值

------------------------------------------------------------------------------------------------

 

 

 

 

 

 

 

 

 

引用

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 类比成“遥控器”

  * 引用变量，保存一个对象的内存地址

* 使用引用变量，可以找到内存中一个对象的内存空间，并访问它的属性数据，或控制让它执行指定方法  

  * 引用的特殊值 null      

      null 空      不保存任何对象的内存地址

 

 

构造方法

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

* 创建构造方法

语法格式：

< 修饰符>  <类名>([<参数表>]) {

     [< 语句>]

}

  * 新建对象时执行的特殊方法        

        new Soldier()

        new Car()

        new Point()

        new Point(2,3)

  * 如果不编写构造方法，编译器编译时，会添加默认构造方法        

        public class Point {

            public Point() {

            }

        }

        

  * 构造方法作用：不知道（当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，我们可以在这个方法中加入要完成初始化工作的代码）

        可以自己定义构造方法，并在其中编写任意代码          

        *) 常见用法： 对成员变量初始化(赋值)  

  * 构造方法重载 Overload        

        *) 可以定义多个不同参数的构造方法  

  * this(...)        

        *) 在构造方法中，调用其他重载的构造方法

        *) 一般在参数少的方法中，调用参数多的方法              

              *) 参数处理代码，集中在一个方法中写，其他方法调用这段代码        

        *) 必须是首行代码

 

  * this.成员        

        *) this 是一个特殊的引用，保存当前对象的内存地址              

              当前对象：正在调用的对象        

        *) 用 this可以引用当前对象的成员              

              this.id

              this.name

              this.toString()

              this.distance()

  

        *) 如果有同名的局部变量，必须用 this才能引用成员变量

 

方法重载 Overload

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 同名不同参

*）参数的数量不同

*）参数的数据类型不同

*）参数中不同的数据类型的顺序不同（无视参数名称）

* 重载的本质

------------------------------------------------------------------------------------

*  Java根据方法名称、参数的数据类型序列来判断方法的唯一性，而不是仅通过方法名称，所以，重载的本质是多个方法

*  在程序运行时，会根据给出的参数值匹配到对应的方法

*  使用重载可以有效的解决方法的命名问题

 

 

继承

继承是一种利用已有的类，快速创建新的类的机制；被继承的类为父类，得到继承的类为子类；通过继承，子类将拥有父类全部属性和方法。

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 作用： 代码重用、代码复用  

  * A 继承 B      

      *) A 是 B的子类

      *) B 是 A的父类  

  * 单继承      

      *) 一个子类，只能有一个父类

      *) 一个父类，可以有多个子类

  * 构造方法，不继承

  * 新建子类对象的过程：      

      1) 新建父类对象

      2) 新建子类对象      

      *) 两个对象绑定在一起，作为一个子类对象  

      *) 调用子类成员时，先找子类，再找父类  

  构造方法执行过程

  --------------------------------------------------------------

    1) 新建父类对象时，执行父类构造方法

    2) 新建子类对象时，执行子类构造方法    

     *) 默认执行父类无参构造方法          

           super()    

     *) 手动调用父类有参构造方法          

           super(参数)    

  * 方法重写 Override      

      *) 继承的方法，对子类不适用，可以在子类中重写这个方法      

      *) super.xxxx()          

          在子类中重写一个方法时， 可以手动调用父类的同一个方法，来减少代码重复

 

 

  super

  ---------------------------------

    1. 重写时，调用父类同一个方法的代码          

          super.toString()    

    2. 手动调用父类构造方法          

          super(参数)          

          *) 必须是首行代码          

 

 

 

多态

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 作用： 一致的类型        

        所有不同的子类型对象，都可以作为一致的父类型被处理

  * 类型转换      

      *) 向上转型        

            *) 子类对象，转为父类型            

            *) 向上转型之后，只能调用父类中定义的通用成员；

               不能调用子类中扩展的成员      

      *) 向下转型            

            被转为父类型的子类对象，再转回成子类型            

  * instanceof      

      *) 对真实类型及其父类型判断，

         都返回 true      

       Shape s = new Line();      

       s instanceof Line     true

       s instanceof Shape    true

 

 

抽象类

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 半成品类（没有完成的类）

  * 作用：

      *) 通用代码

      *) 通用方法的定义  

  * 抽象类，不能创建对象（不能被实例化）  

  * 包含抽象方法的类，必须是抽象类

  * 抽象类中，不一定有抽象方法

 

 

 

 

 

 

 

 

 

final

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 用来修饰变量、方法、类  

  final 变量

  ---------------------------------

    * 变量的值不可变，成为“常量”        

        final int a = 10;

        //a = 11;                

        final Point a = new Point(2,3);

        a.x = 20; //对        

        //a = new Point(8,9);    

  final 方法

  ---------------------------------

    * 不能在子类中重写  

  final 类

  ---------------------------------

    * 不能被继承，没有子类  

 

 

 

 

static

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 静态

  * 静态成员属于类，而不属于对象 

        class A {

            int i = 10;

            static int j = 20;

        }  

  * 一般调用静态成员，使用类名调用 

        A.j = 30;

  

  * 什么时候使用静态 

        *) 使用原则： 能不用就不用 

              静态是“非面向对象”的语法  

        *) 使用场景： 

              *) 共享的数据

              *) 常量

                   static final

              *) 工具方法

                   Math.sqrt()

                   Math.random()

  

  

访问控制符

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 用来控制一个类，或类中的成员的访问范围

               

 

  *) 选择原则： 尽量小范围访问

      public 是与其他开发者的一个契约，公开的类或成员，会保持稳定不变

 

 

接口

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 极端的抽象类

  * 作用： 结构设计工具，用来解耦合  

  * 用 interface代替 class关键字

  * 用 implements代替 extends关键字  

  * 接口中只允许定义：      

      *) 公共的常量

      *) 公共的抽象方法

      *) 公共的内部类或内部接口  

  * 子类可以实现多个接口      

      class A implements B,C,D {

      }      

  * 接口之间继承      

      interface A extends B,C,D {

      }

 

 

内部类

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

  * 定义在类中、方法中、方法内的局部代码块中  

  * 非静态内部类      

      class A {

          class Inner {

          }

      }      

      *) 非静态内部类的对象，依赖于外部类对象才能存在         

         A a = new A();

         //使用外部类对象，来新建内部类对象

         A.Inner i = a.new Inner();         

      *) 非静态内部类中，不能定义静态成员    

  * 静态内部类  

      class A {

          static class Inner {

          }

      }

      

      ----

      

      A.Inner i = new A.Inner();  

  * 局部内部类  

      class A {

          Weapon f() {

              class Inner implements Weapon {

              }              

              Inner i = new Inner();

              return i;

          }

      }                  

  * 匿名内部类  

      Weapon w = new Weapon() {

          ...

      };  

      *) 大括号是匿名类

      *) new 新建这个匿名类的对象

      *) Weapon 作为匿名类的父类型