面向对象的特性

一.什么是对象

在Java 中，任何东西都可以被看做一个对象。

在Java语言的编程世界中，要将所有事物转化为对象来思考问题，其步骤可分为：

1.将现实世界中的实体抽象为对象；

2.分析这个对象都具有哪些属性和行为。

需要注意的是，尽管可以将现实世界中的一切事物都当做对象来看待，我们用来操作的并不是对象本身，而是对象的引用。对象及其引用是相对独立的，也就是说，一个引用的存在并不代表一定有一个对象已经与其建立了连接关系。正确的做法是在声明一个引用的同时对其进行初始化。例如：

   int[] a = new int[3];

二.面向对象的特性

1.封装

   它是面向对象编程的核心思想，其实指的就是将描述某种实体的数据和基于这些数据的操作结合到一起，形成一个封装体。而这个封装体通常情况下都以类的形式出现，类又对操作者隐藏其实现细节，这也就是封装的思想。封装的思想保证了类内部数据结构的完整性，使用户无法轻易直接操作类的内部数据，这样就降低了对内部数据的影响，提高了程序的安全性和可维性。

   优点：

   1.便于编程人员方便快捷地，正确的理解和使用，有效地避免了编程人员因修改类的属性而引发的错误。

   2.更为清晰的体现了程序间的松散耦合关系，提高了应用程序中功能模块的独立性。

    3.提高了软件代码的可重用性。

    4.降低了大型应用程序构建时的风险，例如：即使整个应用程序不成功，但其个别独立的子系统（功能模块）仍然具有可以重用的价值。

   例1.对类中属性的封装

  

               public class Car {
                      //对属性的封装
                       private String brand;    //品牌
                       private double length;    //长度
                       private double width;     //宽度
                       private int seats = 5;     //座位数
                       public String getBrand(){
                                return brand;
  
                        }
                       public void setBrand(String brand){
                                this.brand = brand;
                        }
                        public double getLength(){
                                return length;
  
                         }
                        public void setBrand(double length){
                                this.length = length;
  
                         }
                         public double getWidth(){
                                 return width;
  
                          }
                          public void setWidth(double width){
                                  this.width = width;
                          }
                           public int getSeats(){
                                   return seats;
  
                          }

                      }

    例2.对方法的封装

 

          public class Output {
                public void output(String str){
                        System.out.println(str);
                 }

          }

       这样就实现了对方法Output（）的封装，在方法的调用过程中，先将所需调用方法所在的类进行实例化，再通过类的实例进行方法的调用。如例3.

     

   例3.

                public class Test {
                        public static void main(String[] args) {
                                String str = "这是封装的示例";
                                Output out = new Output();
                                out.output(str);
    
                         }

                }

 

                                         

 

2.继承

   继承反映的是两个类之间的一种关系。当一个类具有另一个类的所有属性和方法时，我们称前者继承了后者，这两个类具有继承关系，称前者为父类或基类，后者为子类或派生类。

  继承是通过关键字extends来实现的。如

    例4。

                         public class A {
                                 String a = "我是A类";
                                 public void showA(){
                                         System.out.println(a);
                                  }
   

                           }

   再创建一个类，命名为B。B继承于A。

                         public class B extends A{
                                 String b = "我是B类";
                                 public void showB(){
                                         System.out.println(b);
                                  }
                                  public static void main(String[] args) {
                                           B b = new B();
                                           b.showA();
                                           b.showB();
                                    }

                           }

 

                                        

  3.多态

      简单的讲，多态指的就是在应用程序中出现的“重名”现象。多态允许以统一的风格编写程序，以处理种类繁多的已存在的类及其相关类。这样既降低了维护的难度，又节省了时间。

    在Java语言中，多态性主要表现在以下几个方面：

 1）方法重载

     其通常指在同一个类中，相同的方法名对应着不同的方法实现，这些相同方法名的方法其区别在于方法所需要的参数不同。即采用不同的方法形参表，区分重载方法要求形参在数据类型，个数和顺序的不同。

  

    例5

                  public class TestPolymorphism1 {
                          String s = "这是方法重载的示例！";
                          String ss = "这是类TestPolymorphism1";
                          public void show(){
                                  System.out.println(ss);
                           }
                          public void show(String str){
                                  System.out.println(str);
                           }
                           public static void main(String[] args) {
                                  TestPolymorphism1 test = new TestPolymorphism1();
                                  test.show();
                                  test.show(test.s);
                           }

                   }

 

 

                                           

 

2）方法重写

    方法重写主要应用于父类与子类之间。子类重写父类中的方法，只是对应的方法实现不同，其方法名与所需要的参数都相同。

    例6        定义TestPolymorphism2，让其继承于A。

                       public class TestPolymorphism2 extends A{
                               String p = "这是方法重写的示例！";
                               public void showA(){
                                       super.showA();
                                       System.out.println(p);
                               }
                               public static void main(String[] args) {
                                      TestPolymorphism2 test = new TestPolymorphism2();
                                       test.showA();
                                }

                         }

 

                            

3）抽象类

  在Java语言中，一个类的方法只给出了标准，而没有给出具体的实现流程，这样的类称为抽象类。抽象类是不能被实例化对象的。父类往往会被定义为抽象类。只给出标准而没有给出具体的实现方法称为抽象方法。

4）接口

   在多态的机制中，接口往往比抽象类使用起来更为方便。由抽象方法组成的集合就是接口。