java面向对象理解

一、面向对象理解

    面向对象主要针对面向过程，面向过程的基本单元是函数，面向对象基于面向过程的编程语言，在java语言中万物皆可以看作对象。

    （1） 所有的事物都有两个方面：

                 有什么（属性）：用来描述对象。

                 能够做什么（方法）：告诉外界对象有那些功能。后者以前者为基础。大的对象的属性也可以是一个对象。

               类是对象的抽象，而对象是类的实例，对象都有属性和行为两大要素，属性是对对象的描述，而行为则体现了对象的功能和行为，一个类的使用是通过对该类实例化来完成的。

    （2）为什么要使用面向对象：

            首先，面向对象符合人类看待事物的一般规律。对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。方法的定义非常重要。方法有参数，也可能有返回值。

            注意区分：对象（本身）、对象的实现者、对象的调用者。 分析对象主要从方法开始。
            我们通过类来看待对象，类是对象的抽象。  其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。 对象之间的耦合性一定要低这样才能使每个对象本身做成最好的。

         对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。 实现高内聚就是要最大限度低提高复用性。

二、类

    （1）构造方法：构造方法可以有一个甚至多个，当一个类中有多个构造方法时，被称为构造方法重载，如果定义类时不提供构造方法，系统会给类一个默认无参构造方法，一旦在类中定义了一个构造方法，系统便不再提供默认构造方法，一般建议重写一个。
    （2）类的成员：属性和行为构成了类的成员。

            类的属性：可以是基本数据类型，也可以是引用类型。

            类的方法：方法则体现出了行为，get和set方法作为一种约定被用于提供对属性的操作，尤其在Javabean中这两个方法必不可少并且规定很严格。

    （3） 类的权限修饰符：
            public :公用的：全开放所有类都可以访问。
            private:私有的：即使子类也无法访问。
            protected :子类可以访问，即使不在同一个包中。同一包中的类也可以访问。
          （friendly)默认的：对同一包开放。
             这些修饰符体现了封装的特性。
      其他关键字：
      static静态的：被其修饰的成员将具有静态属性，运行中静态成员被优先加载。对静态方法的访问（类名 .方法名()），不不要实例化后通过对象再访问。
      final最终的：被final修饰的成员（成员变量、成员方法）成员变量（变量变为常量）不能被修改，成员方法不能被重写，同样被final修饰的（类）意味着该类不再有子类。
     abstract抽象的：抽象方法只有方法头，没有方法体，不提供具体方法的具体实现，有其具体子类重写抽象方法并实现，除非这个子类也是abstract修饰的。被abstract修饰的类不能被实例化的（即便它有构造方法），所以一定要通过子类来实例化（需要用到多态）。接口中的方法都是抽 象方法（接口同样不能被实例化，但与抽象类不同的是接口中没有构造方法，而且抽象类跟一般类基本没有太大区别，抽象类也是单继承，接口可以是多实现）
     this（当前类对象的引用）：当前类的成员（this.成员变量），构造方法（tthis ()），成员方法（this.成员方法（））。
     super（super代表父类的内存空间的标识）：语法结构与this一样。在子类实例化时，总是在最先调用父类的构造方法，即使没有写super()，系统一般默认隐提供。

  （4） 抽象类：

           抽象定义：抽象就是从多个事物中将共性的，本质的内容抽取出来。例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

          Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
          抽象方法的由来：多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

         抽象类的特点：

      ●抽象类和抽象方法必须用abstract关键字来修饰。抽象方法只有方法声明，没有方法体，定义在抽象类中。

      ● 格式： 修饰符 abstract 返回值类型  函数名(参数列表) ;

      ● 抽象类不可以被实例化，也就是不可以 用 new 创建对象。原因如下：

          ① 抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。

          ②而且抽象类即使创建了对象，调用抽象方法也没有意义。

          ③抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

  （5）接口

            ●格式：interface 接口名{}

            ●接口中的成员修饰符是固定的。

            ● 成员常量：public static final

            ●成员函数：public abstract，发现接口中的成员都是public的。接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

          （2）接口特点

               ●接口是对外 暴露的规则 。

               ●接口是程序的 功能扩展 。

               ●接口的出现 降低耦合性 。

               ●接口可以用来 多实现 。

               ●类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

               ●接口与接口之间可以有继承关系。
             （3）接口与抽象类的区别

      （6） 内部类：
            定义在一个类内部的类就叫内部类，它只能被包含它的外部类访问。访问内部类必须同过外部类的一个实例来执行。内部类对于外部类的成员具有完全可见性，即内部类可以访问外部类的成员。
           方法内定义的内部类：这个内部类属于这个方法，该方法可以创建该内部类的实例，但外部类的其他方法无法访问该内部类，这种类不能用访问修饰符声明，不能被声明为静态，只能访问所嵌入方法中声明为final的变量，引用方法的局部变量或作为传递给所嵌入方法的参数。
            静态内部类：静态内部类的方法不能访问外部类的实例变量，静态内部类的方法只能访问外部类的静态变量。
            匿名内部类：在事件模型中很有用，直接new。（当只调用一次时使用匿名内部类比较好，资源伴随调用的结束而释放）。

    （7）对象的引用
          与基本数据不同，引用数据是依赖指针进行工作的。故当基本型数据和引用型数据均被当做参数传递给一个方法时，基本型数据会复制一个完全一样的数据传入方法，在方法中对传入的数据进行操作是完全不会影响到方法外的这个数据，而引用型则通过将地址传入方法进行操作，所以当方法对这个参数进行任何的改动都会直接影响到方法外的这个引用型数据。

三、封装

       概念：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

1、 好处

       ①将变化隔离便于使用。 ②提高重用性。③提高安全性。

2、原则

        ①  将不需要对外提供的内容都隐藏起来。         ②  把属性都隐藏，提供公共方法对其访问。

3、封装的表现形式之一——private（私有）

        private关键字：权限修饰符；用于修饰类中的成员（成员变量，成员函数），私有只在本类中有效。

       例如：将成员变量私有化，对外提供对应的set和get方法对其进行访问。提高对数据访问的安全性。

      例如： 我有一个人对象，而年龄这一属性我不想被对象访问，我就可以将其设为private。

public class PersonMain {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(-10);
        p.speak();
    }
}

class Person {//描述任务对象的类
    
    private String name; //定义对象的属性，姓名
    private int age;//定义年龄
    
    public String getName() {//提供获取属性的方法
        return name;
    }
    
    public void setName(String name) {//提供设置属性的方法
        this.name = name;
    }
    
    public int getAge() {//提供设置属性的方法
        return age;
    }
    
    public void setAge(int age) {//提供获取属性的方法
        if(age > 0 && age < 130){
            this.age = age;
            speak();
        }else{
            System.out.println("您输入的年龄非法");
        }
    }
    
    public void speak() {//对象说的功能
        System.out.println("age"+age);
    }
}

 四、继承

           多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。子类可以直接访问父类中的非私有的属性和行为。通过extends 关键字让类与类之间产生继承关系。

          1.格式：classSubDemo extends Demo{}

          2.继承的优点： ①提高了代码的复用性。②让类与类之间产生了关系，提供了多态的前提。

          继承的特点：

         Java只支持单继承，不支持多继承，通过另一个方式体现。一个类只能有一个父类，不可以有多个父类。

                class SubDemo extends Demo{} //ok

                class SubDemo extends Demo1,Demo2...// error

        Java支持多层继承(继承体系)

                class A{}

                class B extends A{}

                class C extends B{}

        ★定义继承需要注意：不要仅为了获取其他类中某个功能而去继承 ，类与类之间要有所属(" is a " )关系，xx1是xx2的一种。

         3.方法重载：发生在同一类中，方法名相同，方法的参数列表不同。与返回值类型无关。

         4.方法重写：发生在继承关系下的不同类中，方法名和方法参数以及返回类型都必须相同。

五、多态

Java中多态性的实现

1、什么是多态

1. 面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
2. 多态的定义：
3. 实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
4. 多态的好处与作用：多态的存在提高了程序的扩展性和后期可维护性

2、前提：

         ①需要存在继承或者实现关系②要有覆盖操作
3、特点

    成员函数：

           编译时：要查看引用变量所属的类中是否有所调用的成员。

          在运行时：要查看对象所属的类中是否有所调用的成员。

   成员变量：

          只看引用变量所属的类。