黑马程序员_面向对象总结

一.面向对象

    1. 概念:它是一种思想,是基于面向过程的,它研究的主体是对象.

        面向过程也是一种思想.它是以函数为基础,完成各种操作,强调的是过程.

        面向过程是以对象为基础,完成各种操作,强调的是对象.

   2.特点:

        (1)更符合人们的思维习惯.

        (2)使程序员由执行者转变为指挥者.

        (3)把复杂的事情简单化.

  3.举例:

          做饭:  

                  面向过程:自己要买菜,洗菜.烧菜.最后吃饭就可.

                  面向对象: 找一个会做饭的人,给他说要吃啥饭,最后吃饭就可以.

   4.特征:

            封装    继承   多态

   5.怎么样才能让我们的操作更符合面向对象的思想呢？
        1、分析该系统中有那些对象。
             A：名词提取法。
             B：UML统一建模语言，闫闳
        2、每个对象的功能。
        3、明确各个对象之间的关系。

   6.类与对象的关系概述：
      理解性：
              开发：就是不断的创建对象，使用对象，指挥对象做事情。
              设计：维护和管理各个对象之间的关系。
              学Java就是为了把现实世界的事物通过编程语言给体现出来。
               Java描述事物无非就是描述事物的：属性和行为。
      掌握：
             属性：外在特征。
             行为：能够做什么。
      Java语言最基本的单位是：类 。
       计算机最基本的存储单位是：字节。

       类：属性和行为的集合体，一个抽象的概念。
       对象：类的具体实现，体现。
       成员变量；属性。
        定义在类中，方法外的变量。
       成员方法：行为。
   例子: 写一个学生类：
          1、分析学生事物
              属性：姓名，年龄，性别
              行为：学习，吃饭，睡觉
          2、把分析后的学生事物转成Java中的类：
              学生类；
              成员变量：
                    姓名：name
                    年龄；age
                    性别：sex/gender
               成员方法：
                    学习：study()
                    吃饭；eat()
                  睡觉: sleep()
     如果使用学生类中的内容？
       1、想使用学生类中的内容，必须明确通过那个学生来调用。
       2、怎么明确一个的具体对象？
             通过new关键字。
                     格式：类名 对象名 = new 类名();
        3、怎么使用类中的成员（成员变量，成员方法）。
             成员变量： 对象名.成员变量;
             成员方法： 对象名.成员方法();

     怎么给成员变量赋值？
         对象名.成员变量 = 值;
  什么时候定义成员变量?
         只有能够用于描述一个类的属性的东西，才可以定义为成员变量。
  注意：
         使用变量的时候，遵循一个“就近原则”。
         会现在局部范围内找，有就使用，没有就去成员位置找，有就使用，没有就报错。（先这样记，不严谨）

   成员变量和局部变量有什么区别？
       A：定义位置不同。
               成员变量：类中，方法外。
               局部变量：方法中，或者方法的形参上。
     B：初始化值不同：
              成员变量：有默认初始化值。
              局部变量：没有默认初始化值，必须先定义，再赋值，然后才能使用。
C：存储位置不同（生命周期不同）：
             成员变量：堆。随着对象的创建而存在，随着对象的消失而消失。
             局部变量：栈。随着方法的调用而存在，随着方法调用完毕而消失。

   匿名对象：
       概述：没有名字的对象。
      应用场景：
               A：当对 对象(成员)方法仅调用一次的时候。
               B：匿名对象可以作为实际参数进行传递。

二.继承extends

    1. 概念:隐藏对象的属性和实现细节，仅对外提供一个公共的访问方式。

       怎么隐藏？
              private：是一个访问权限修饰符，表示私有的意思。他可以来修饰成员变量和成员方法。
                             被它修饰的内容，在其他类中不能被直接访问。
       公共的访问方式是什么？
          set方法：赋值。
           命名格式： set+成员变量名
        举例： public void setName(String n){ name = n; }
        public void setAge(int a){ age = a; }
        get方法：取值。
       命名格式： get+成员变量名
      举例：
             public String getName()
             {
               return name;
             }
              public int getAge()
            {
            return age;
              }
      注意：
            private仅仅是封装的一种体现，咱们之前学过的类，函数都是封装的体现。
            咱们写的功能代码（比如说：判断，求和，比较最大值），必须写在函数中。

      构造方法：
         特点：
            (1)方法名必须和类名一致(包括大小写)。
            (2)没有返回值类型。
            (3)没有具体的返回值。
          作用：对对象进行初始化（创建对象的）。
     注意事项：
           (1)如果我们没写构造方法，系统会默认提供一个无参构造。
           (2)如果我们写了构造方法，系统将不再提供默认的无参构造。
               推荐：永远手动给出无参构造。
           (3)构造方法可以重载。
           就是构造方法可以接受不同类型的参数。
      一般我们定义类的时候，都会写上无参构造，
     带参构造根据需求，可写可不写，写的话，一般是带全参。
    给成员变量赋值的两种方式：
         (1)通过set方法。(推荐)
         (2)通过构造方法。

      这两种赋值方式有什么区别？
构造方法强调的是创建对象,赋值是附带功能,不能取出其中一个变量的值,

        set.get方法,强调的就是赋值,它可以取任一一个变量的值
     2.this关键字： 
        概述：代表其所在方法所属对象的引用。
        换言之：this代表本类对象的引用（记忆）。
        大白话：那个对象调用方法了，在方法内部就有一个隐含的this代表这个对象。
        应用场景：
             (1)用于解决局部变量隐藏成员变量值的问题。

       编写一个狗（Dog）的标准代码，要求如下：
      属性：姓名，年龄
       功能：定义一个功能show，能够输出狗的年龄

   代码块：
     概述：由{}扩起来的内容。
     分类：局部代码块,构造代码块
     局部代码块：
    概述：方法内部。
    作用；让变量尽可能早的从内存中消失，提高效率。
    构造代码块：
    概述：类中，方法外。
     作用：把所有构造方法的同性内容提取出来，放在构造代码块中。
     因为先执行构造代码块，后执行构造方法。

    3.static关键字：
       概述：它是一个关键字，可以用来修饰成员变量和成员方法。
       被它修饰的成员，能被该类下所有的对象所共享(资源共享)。
       举例：
       班级的钱包。
      特点：
          (1)随着类的加载而加载。
          (2)优先于对象存在的。
          (3)资源共享。
               如果某个内容是被该类下所有的对象所共享的，就可以使用静态修饰，
               没有被静态修饰的内容，其实是属于对对象的特殊描述。
           (4)直接被 类名点 的方式调用。
          注意事项：
           (1)静态方法中是没有this关键字。
          (2)静态方法只能访问静态成员变量和静态成员方法。
          (3)静态成员可以直接被类名调用，也可以被对象调用。
            推荐使用：类名点的方式调用。

   4.封装的标准代码块

  Person p = new Person();

     封装的标准代码：
      class Teacher
      {
         private String name;
         private int age;
         private static String country;
    public Teacher()
   {
   }

     public void setName(String name)
    {
      this.name = name;
    }
    public String getName()
   {
     return name;
   }

    public void setAge(int a)
   {
     this.age = age;
    }
    public int getAge()
   {
     return age;
    }
}
class TeacherTest
{
     public static void main(String[] args)
{
//创建一个Teacher类的对象，分别给姓名和年龄赋值，然后输出结果
      Teacher t = new Teacher();
       t.setName("jake");
       t.setAge(18);
      System.out.println(t.getName()+"***"+t.getAge());
}
}
三.继承

     1.概述：把多个类中的同性内容提取出来放到一个单独的类（A）中，然后让这多个类和类A产生关系，
这样，这个多个类就具备了类A的功能，这种技术，就叫继承。
格式：
class A extends B 
{

}
叫法：
类A：子类，派生类
类B：父类，基类，超类，
注意：
子类可以直接访问父类中的所有非私有成员。


案例：
父类：Person
子类：Student
class Person
{
public void show()
{
sop("nihao");
}
}
class Student extends Person 
{
public void show()
{
sop("nihaoma ?");
}
}

}
class Demo
{
Student s = new Student();
s.show();
Student s1 = new Student();
}


继承使用是需要注意 的问题是？
子类可以直接访问父类中的所有非私有成员。
子类中如果想使用父类私有的成员变量怎么办？
1、通过父类的公共访问方式。
2、通过调用父类的其他带参构造(了解)。


   2.继承的好处和特点：
好处：
(1)提高代码的复用性。
(2)让类与类之间产生一个关系，是多态的前提。
特点：
(1)Java支持单继承，不支持多继承。
(2)Java支持多层继承（继承体系）。
类A继承类B，类B还可以继承类C，类C还可以继承。。。。
   3.类的组成：
   成员变量
        使用变量，遵循一个就近原则，先在局部范围找，没有就到本类的成员位置找，如果没有就到父类的成员                                   位置找.如果还没有，就报错。
         在子类中，想输出本类的局部变量，成员变量，父类的成员变量值，
              局部变量：直接输出。
              成员变量：this.变量名。
             父类的成员变量：super.变量名。
              如果他们的变量名不同，直接输出即可。
   this和super有什么区别？
     this：代表本类对象的引用。
     super：代表父类的内存空间标识（可以理解为父类对象的引用）。
   this和super的用法：
     成员变量；
       this.成员变量：本类的成员变量
       super.成员变量：父类的成员变量
     构造方法：
       this(参数)：本类的其他构造方法。
       super(参数)：父类的构造方法。
    成员方法：
       this.方法名()：本类的成员方法
       super.方法名()：父类的成员方法
  
方法重载和方法重写有什么区别？
     方法重载：同一个类中，出现方法名相同，参数列表不同的两个或多个方法时，即构造方法重                                                            载。
                        方法的重载与返回值的数据类型无关。
    方法重写：子父类间，出现一模一样的方法时，被称为方法的重写，或者复写。
 注意：方法重写，要求一模一样。包括返回值的数据类型。
    方法覆盖需要注意哪些问题？
        1、父类的私有方法不能被子类重写。
        2、子类方法的访问权限一定要大于等于父类方法的访问权限。
        3、静态方法只能被静态方法重写。（这个不算子类间对象的成员关系）
    方法重写的应用场景：
        当子类需要使用父类的某个功能，并且在这个功能的主体上需要加入自己特有内容的时候，
        就可以考虑使用方法的重写，这样，即沿袭了父类的功能，又加入了自己的功能。


     构造方法
        子父类间构造方法的执行顺序：
        子类的所有构造方法默认都去访问了父类的无参构造，
         原因是，子类的所有构造方法之前有一行默认的代码：super();
         为什么要这样做呢？
             子类默认具备了父类的非私有数据，而父类的数据的初始化是靠父类自己来完成的。
             所以在子类的构造方法执行前，需要先执行父类的构造方法对父类数据进行初始化。
     如果父类没有无参构造怎么办？
           1、通过super(参数)的形式来调用，父类的其他带参构造。
           2、通过this(参数)的形式来调用本类的其他带参构造。
      一个关于代码块的面试题：
            父类的构造方法，子类的构造方法
            父类的构造代码块，子类的构造代码块
            父类的静态代码块，子类的静态代码块。
    如果子父类都有静态代码块，构造代码块，构造方法，那么他们之间的执行顺序是什么？
          父类的静态代码块  -- 》子类的静态代码块 --》 父类的构造代码块 --》父类的构造方法
            --》 子类的构造代码块 --》子类的构造方法

    final关键字：
      概述：它是一个关键字，表示最终的意思，它可以修饰类，成员变量，成员方法。
        它修饰的类，不能被继承，但是可以继承其他类。
       它修饰的成员变量，其实是一个常量。
      常量的分类：
            字面值常量； 123,32，"Hello"
            自定义常量：格式跟咱们定义变量一样，加一个final即可。

           它修饰的成员方法，不能被子类重写。

  四.多态
(1)对象在不同时刻表现出来的不同状态。
举例：狗（狗、宠物、动物）
(2)多态的前提
A:要有继承或者实现关系。
B:要有方法的重写/实现。
C:要有父类引用或者父接口引用指向子类对象。


注意：多态有三种体现形式
类多态
抽象类多态
接口多态
(3)多态中的成员特点：
A:成员变量
编译看左边，运行看左边。
B:成员方法
编译看左边，运行看右边。


为什么?因为方法存在重写，而变量没有。


举例：孔子扮父。
(4)多态的弊端：
父类(接口)引用不能使用子类特有功能。
为了解决这个弊端，我们需要向下转型。


Fu f = new Zi(); //向上转型
Zi z = (Zi)f; //向下转型


Zi z = new Zi();
(5)多态的好处：
可以提高代码的扩展性和可维护性。


2:抽象类
(1)如果多个类中存在相同的方法声明，而方法体不一样，我们就可以只提取方法声明。
  如果一个方法只有方法声明，没有方法体，那么这个方法必须用抽象修饰。
  而一个类中如果有抽象方法，这个类必须定义为抽象类。
(2)抽象类的特点
A:抽象类和抽象方法必须使用abstract修饰
B:抽象类不能被实例化
C:抽象类有构造方法，用于子类实例化使用
D:如果一个类是抽象类，那么，继承它的子类
要么是抽象类。
要么重写所有抽象方法。
(3)抽象类的成员特点
A:成员变量 可以变量，也可以是常量
B:构造方法 有构造方法
C:成员方法 可以有抽象方法，也可以有非抽象方法（全是抽象方法或者非抽象方法都是可以的）
(4)抽象类的几个小问题
A:抽象类不能被实例化，为什么有构造?
用于子类实例化使用。
B:一个类没有抽象方法，为什么定义为抽象类?
不想被实例化，或者是抽取出来的一个规则类
C:abstract不能和哪些关键字共存。
final
private
static

3:接口
(1)如果一个抽象类中的方法都是抽象的，这个时候，java就提供了一种
  更抽象的表示形式：接口。
  接口：interface
  实现：implements


  格式：
interface 接口名{}


class 类名 implements 接口名 {}
(2)接口的特点：
A:接口不能被实例化。
B:一个类如果实现了接口：
要么是抽象类。
要么实现接口中的所有方法。
(3)接口的成员特点：
A:成员变量 只能是常量。默认修饰符 public static final
B:成员方法 只能是抽象方法。默认修饰符 public abstract
(4)接口的思想特点：
A:对外暴露的规则
B:是功能的扩展
C:降低耦合度
耦合：类与类的关系
内聚：类自己完成某件事情的能力


高内聚，低耦合。
D:接口可以多实现。
(5)类，接口的关系
A:类与类
继承关系,只能单继承，可以多层继承。
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时实现多个接口。
C:接口与接口
继承关系，可以单继承，也可以多继承。
(6)抽象类和接口的关系?自己补齐。
                接口是一种特殊的抽象类，比抽象类更抽象，因为它里