黑马程序员———面向对象

------- android培训、java培训、期待与您交流！ ----------

 

 

 

1：对象内存图
 创建一个对象实例的过程：
 main方法执行前的准备工作：
  将类加载到内存当中
  静态区的成员(方法，属性)
 1、定义一个变量来接收一个对象实例
 2、通过new关键字在堆内存中开辟空间
 3、将成员变量默认初始化
 4、如果有静态代码块，先静态代码块。如果有构造代码块，先执行构造代码块。构造方法将成员变量进行显式初始化
 5、变量指向对象实例的内存地址
1：成员变量和局部变量的区别
 (1)定义位置区别：
  成员变量：定义在类中，方法外。
  局部变量：定义在方法中，或者方法声明上。
 (2)初始化值的区别：
  成员变量：都有默认初始化值。
  局部变量：没有默认初始化值。要想使用，必须先赋值。
 (3)存储位置区别：
  成员变量：存储在堆中。
  局部变量：存储在栈中。
 (4)生命周期区别：
  成员变量：随着对象的创建而存在。随着对象的消失而消失。
  局部变量：随着方法的调用而存在，随着方法调用完毕而消失。更严谨地说当局部变量的作用域结束时，即被销毁。

 就近原则：局部变量有，就用局部变量，局部变量没有，就找成员变量。如果成员变量也没有就报错

2：封装
 (1)隐藏实现的细节，提供公共的访问方式。
  类，方法等其实都是封装的具体体现。
 (2)private关键字
  A:用于修饰成员变量和成员方法。
  B:被修饰的内容在其他类中是不可以被访问的。
 (3)常见的应用：(掌握)
  类中的所有成员变量私有，给出对应的get/set方法。
  
  代码体现：
  
  class Student
  {
   private String name;
   private int age;

   public Student(){}

   public Student(String name,int age)
   {
    this.name = name;
    this.age = age;
   }

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

   public String getName()
   {
    return name;
   }

   public void setAge(int age)
   {
    this.age = age;
   }

   public int getAge()
   {
    return age;
   }
  }

3：构造方法
        用来创建实例对象
 创建同时可以给属性赋值
 (1)格式及特点
  格式：
   访问权限修饰符 类名(参数...){}

   访问权限修饰符:
    public,private
  特点：
   A:方法名和类名相同
   B:没有返回值类型
   C:没有具体的返回值
 (2)注意事项：
  A:如果你不给构造方法，jvm会自动给你一个无参构造方法。
  B:如果你给出了构造方法，那么，jvm将不再提供无参构造方法。
    这个时候，你如果要使用无参构造方法：只能自己提供

    推荐：永远手动给出无参构造方法。

4：this关键字
 (1)是一个关键字。代表当前对象的引用。
  //简单记：在方法中，哪个对象调用方法，this就代表谁。
 (2)应用场景：
  解决局部变量隐藏成员变量问题。
  在构造方法中调用其他的构造方法(必须写在第一行)

5：static关键字
 (1)是一个关键字。可以修饰成员变量和成员方法。
 (2)静态的特点：
  A:随着类的加载而加载
  B:优先于对象存在
  C:被类的所有对象共享
  D:可以通过类名调用
 (3)静态的注意事项：
  A:在静态方法中是没有this关键字的。
  B:静态方法只能访问静态的成员变量和静态的成员方法。
 (4)静态内容的调用：
  A:被对象调用
  B:被类名调用

  推荐被类名调用。
 (5)什么时候该用static呢?
  如果某个内容是所有对象共享的，就用静态修饰。
  举例：
   水杯和饮水机。
   厕所和人。
   老师和学生。
   对于传智学生都是热爱编程。

6：Math类的随机数
 类名调用静态方法。
 
 包：java.lang
 类：Math
 方法：public static double random():
 
 java.lang包下的类是不用导包就可以直接使用的。

 产生1-100之间的随机数：
 int number = (int)(Math.random()*100)+1;

1：如何使用API。(掌握)
 A:找到文档，打开文档。
 B:点击左上角的显示变成隐藏，然后点击索引
 C:你应该知道你要找谁?Math
  所以，你就在那个输入框里面输入Math，然后回车，再回车。
 D:看这个类的结构
  java.lang
   类 Math

  java.util
   类 Scanner

  如果是java.lang包下的类，是可以直接使用的。(Math)
  否则，就需要导包才能使用。(Scanner)
 E:看看对这个类的说明。  
 F:看构造方法
  名称：字段 -- 成员变量 -- 属性。

  a:有构造方法，那么，就通过构造方法创建对象使用。
  b:没有构造方法，那么，这个类的成员一般都是静态。
   通过类名调用。
 G:按照正常的操作使用方法。
  左边：
   是否静态：如果静态修饰，那么可以通过类名调用。否则，就必须创建对象调用。
   是否有明确返回值：如果是void类型，就直接调用即可。否则，就可以输出或者赋值。
  右边：
   看方法名：不要写错了。
   看参数：看参数类型及个数。

2：继承
 (1)把多个类中的相同的属性和行为进行抽取，封装到一个类中，
    然后再建立新类的时候，不需要从头做起，继承刚才定义的那个类即可。
 (2)好处：
  A:提高代码的复用性。
  B:让类与类之间产生了一个关系，是多态的前提。
 (3)什么时候使用继承?
  A:如果类之间存在着:
   is a 的关系，就可以考虑使用继承。
  B:不要为了继承部分功能，而去使用继承。
 (4)继承的特点：
  A:Java只支持单继承，不支持多继承。
   为什么?如果支持多继承，就会有调用不明确的问题。
  B:Java支持多层(重)继承。
 (5)super和this的区别?
  A:super是一个关键字，代表父类的存储空间标识。(可以理解为父亲对象的引用)
  B:它和this的用法相似
   a:成员变量
    this.变量 -- 本类的
    super.变量 -- 父类的
   b:构造方法
    this(...) -- 本类的
    super(...) -- 父类的
   c:成员方法
    this.方法名() -- 本类的 
    super.方法名() -- 父类的
 (6)子父类中成员变量的用法：
  A:名称不同，这个太简单了。
  B:名称相同，子类对象的在使用的时候：
   
   先找子类局部范围
   再找子类成员范围
   最后找父类成员范围
   父类的父类成员范围
 (7)子父类中成员方法的用法：
  A:名称不同，这个太简单了。
  B:名称相同，子类对象的在使用的时候：
   先找子类的
   再找父类的
  C:方法重写
   在子类中，方法声明(修饰符,返回值,方法名,参数列表)相同的情况。

   注意事项：
    a:父类中私有方法是不能被重写
    b:子类方法的访问权限一定要大于等于父类的访问权限
    c:静态只能重写静态。(这个不能算，因为静态跟类相关)
 (8)子父类中构造方法的用法：
  A:子类的初始化过程中，首先回去执行父类的初始化动作。
     因为子类的构造方法中默认有一个super()。
   为什么?子类要使用父类的成员变量，这个初始化，必须在子类初始化之前完成。
   所以，子类的初始化过程中，会先执行父类的初始化。
  B:如果父类没有无参构造方法
   A:使用super调用父类的带参构造。推荐方式。
   B:使用this调用本身的其他构造。
3：代码块(面试题)
 (1)执行顺序：
  静态代码块 --> 构造代码块 --> 构造方法
  默认初始化>显式初始化>构造代码块初始化>构造方法初始化
 (2)注意事项：
  静态代码块只执行一次

4：final
 (1)是一个关键字，可以用于修饰类，成员变量，成员方法。
 (2)特点：
  它修饰的类不能被继承。
  它修饰的成员变量是一个常量。
  它修饰的成员方法是不能被子类重写的。

掌握形，而不是神。
形似不用神似。

理解多态概念，完成上课例子。

1:多态
 (1)同一个对象在不同时刻表现出来的不同状态。
  另外的表达方式：针对同一个对象，编译期类型和运行期类型不一致。
  举例：
   狗(狗是狗,狗是动物)
   水(水，水蒸气，冰)
 (2)前提：
  A:有继承或者实现关系。
  B:有方法重写。
  C:有父类或者父接口引用指向子类对象。
 (3)好处和弊端：
  A:好处
   扩展性和维护性(是由继承保证)。
  B:弊端
   不能使用子类的特有功能。
 (4)向上转型和向下转型
  A:向上转型
   把子类对象赋值给父类或者父接口引用
  B:向下转型
   把父类或者父接口引用强制转换为子类
 (5)多态中的使用成员特点
  A:成员变量
   编译运行都看左边
  B:成员方法
   编译看左边，运行看右边。

  举例：Gosling儿子装爹。
 (6)多态的体现形式
  A:具体类多态(几乎不用)
  B:抽象类多态
  C:接口多态

2:抽象类
 (1)多个具体的事物具备相同的方法声明，而方法体不同，我们就只抽取方法声明，然后定义到一个类中。
    而一个没有方法体的方法是一个抽象方法，一个类中有抽象方法，该类必须定义为抽象类。
 (2)抽象类的特点：
  A:抽象类或者抽象方法用abstract修饰。
  B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
  C:抽象类不能被实例化。
  D:子类继承抽象类，要么是抽象类，要么重写所有父类抽象方法。
 (3)抽象类的几个小问题
  A:不能被实例化，要构造方法干啥?
  B:一个类中没有抽象方法，居然定义抽象类，有什么意义?
  C:抽象关键字不能和哪些关键字共存
   a:private
   b:final
   c:static
 (4)抽象类的成员：
  A:成员变量 有变量，也有常量
  B:构造方法 有构造方法，用于子类访问父类数据的初始化
  C:成员方法 有抽象方法，也有非抽象的方法
 (5)抽象类的案例
  A:老师案例
  B:学生案例
  C:员工案例

3:接口
 (1)当一个抽象类中的方法都是抽象的时候，java就提供了一种更抽象的表达方式，叫接口。
 (2)接口的成员特点：
  A:成员变量 是常量 默认修饰符 public static final
  B:成员方法 抽象方法 默认修饰符 public abstract
 (3)接口的特点：
  A:接口用interface定义
  B:子类实现接口用implements标识
  C:接口不能被实例化
  D:子类实现接口的时候，要么是抽象类，要么全部实现接口方法
 (4)接口和类的关系
  A:类与类的关系
   继承关系,只能单继承，可以多层继承。
  B:类与接口的关系
   实现关系，可以单实现，也可以多实现。
   还可以在继承一个类的同时，实现多个接口。
  C:接口与接口的关系
   继承关系，可以单继承，也可以多继承。
 (5)接口的思想特点(理解)
  A:对外暴露的规则(USB接口)
  B:程序的扩展功能(多态)
  C:降低程序的耦合性(多态)
  D:让类可以多实现
 (6)接口和抽象类的区别
  共性：都是不断抽取出来的抽象的内容。

  A:成员特点
   抽象类：
    成员变量 可以变量，也可以常量
    成员方法 可以抽象，也可以非抽象
    构造方法 有
   接口：
    成员变量 只能是常量
    成员方法 只能是抽象
    构造方法 无
  B:继承或者实现关系特点
   a:类与类的关系
    继承关系,只能单继承，可以多层继承。
   b:类与接口的关系
    实现关系，可以单实现，也可以多实现。
    还可以在继承一个类的同时，实现多个接口。
   c:接口与接口的关系
    继承关系，可以单继承，也可以多继承。
  C:设计区别
   抽象类中定义的是体系的共性内容。表达的是：is a的关系。
   接口中定义的是体系的扩展功能。表达的是：like a的关系。

  案例：运动员和教练案例。
 (7)如何实现一个继承体系
  分析：由具体到抽象
  实现：由抽象到具体

  学习：抽象的内容,因为它定义的是共性内容。
  使用：具体的内容,因为它才是具体实现，才具体更多的功能。