Java 总结二 面向对象阶段

第一章

1. 类与对象
   1. 类，用于描述多个对象的共同特征，它是对象的模板。
   2. 对象，用于描述现实中的个体，它是类的实例。
   3. 类的定义：使用关键字class来定义java中的类
      1. 格式：

            class 类名 {

                //属性

                数据类型 变量名;

                …

                //方法

                修饰符 返回值类型 方法名(参数){   }

                …

            }

1. 1. 创建对象：
      1. 格式：

类名 对象名 = new 类名();

1. 封装（private关键字）
   1. 封装，把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式
   2. 封装的体现：
      1. 变量:使用 private 修饰，这就是变量的封装
      2. 方法:也是一种封装，封装了多条代码
      3. 类： 也是一种封装，封装了多个方法
   3. private关键字，私有的意思
      1. 它可以用来修饰类中的成员(成员变量，成员方法)
      2. private的特点：
         1. private修饰的成员只能在当前类中访问，其他类中无法直接访问
2. this关键字
   1. this关键字，本类对象的引用
      1. this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用
      2. this什么时候存在的？当创建对象的时候，this存在的
      3. this的作用：用来区别同名的成员变量与局部变量（this.成员变量）

            public void setName(String name) {

                this.name = name;

            }

第二章

1. 继承：是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有
2. 继承的好处：可继承的属性和方法。
   1.  

                            提高了代表的可维护性

                            提高了代码的复用性

                            让类与类之间产生了继承关系

1. 1. 继承的弊端：

                            类与类之间的耦合度过高

1. 1. 继承特点：

                            java中类只能够单继承，不能多继承，可以多层继承

                                     class Yy extends Object {}

                                     class Fu extends Yy{}

                                     class Zi extends Fu {}

                            所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类

1. 1. 继承的注意事项：

                            1，使用关键字 extends 让类与类之间 产生继承关系

                            2, 父类私有的成员，子类不能继承，因为根本看不到

                            3，不能为了继承某个功能而随意进行继承操作， 必须要符合 is a 的关系

                                     苹果 is a 水果

                                     男人 is a 人

                                     狗   is a 人 ， 这种情况就不能继承了

1. 1. 继承中的成员变量关系：

                            不同名的变量：

                                     子类直接继承使用

                            同名的变量：

默认访问的是子类自己的成员变量, 想访问父类中的同名变量，请使用 super.成员变量;

1. 1. super:用来表示当前对象中包含的父类对象空间的引用

调用父类的成员变量：

super.成员变量;

                            调用方法的成员方法:

super.成员方法();

1. 1. 方法重写(override)：指 在子父类中，出现了方法声明相同的情况，也叫做方法覆盖，方法复写
      1. 方法重写的注意事项：
2. 子类的方法声明要与父类相同

2, 子类要重写方法的方法，方法的权限修饰符不能比父类的更低

1. 1. 3, 父类私有的方法，子类不能够进行方法重写
   2. 方法重载(overload)：指 在同一个类中，多个方法名称相同，它们的参数列表不同(个数不同，数据类型不同)
2. 抽象
   1. 抽象方法： 方法只有声明部分，没有方法体
   2. 抽象类： 包含抽象方法的类，一定是抽象类

      使用 abstract 修饰的类，是抽象类

1. 1. 抽象类的特点：     

    1，抽象类与抽象方法都必须使用 abstract来修饰       

        2，抽象类不能直接创建对象

        3，抽象类中可以有抽象方法，也可以没有抽象方法

        4，抽象类的子类

            a，实现了抽象方法的具体类

            b，抽象类

1. 1. 抽象类面试题：

        1，抽象类中是否可以没有抽象方法？如果可以，那么，该类还定义成抽象类有意义吗？为什么？

    可以没有抽象方法，有意义，不会让其他人直接创建该类对象

第三章

1. 接口：理解为是一个特殊的抽象类，但它不是类，是一个接口
   1. 接口的特点：

    1，定义一个接口用interface关键字

            interface Inter{}

        2，一个类实现一个接口，实现implements关键字

            class Demo implements Inter{}

        3, 接口不能直接创建对象

           通过多态的方式，由子类来创建对象，接口多态  

1. 1. 接口中的成员特点：

        成员变量：

            只能是final 修饰的常量

            默认修饰符： public static final

        构造方法：

            无

        成员方法：

            只能是抽象方法

            默认修饰符: public abstract

1. 1. 类与类，类与接口，接口与接口之间的关系

        类与类之间：继承关系，单继承，可以是多层继承

        类与接口之间: 实现关系，单实现，也可以多实现

        接口与接口之间：继承关系，单继承，也可以是多继承           

        Java中的类可以继承一个父类的同时，实现多个接口

 

1. 多态：理解为同一种物质的多种形态
   1. 多态使用的前提：

                            1，有继承或者实现关系

                            2，要方法重写

                            3，父类引用指向子类对象

1. 1. 多态的成员访问特点：

                            方法的运行看右边，其他都看左边

1. 1. 多态的好处：

                            提高了程序的扩展性

1. 1. 多态的弊端：

                            不能访问子类的特有功能

1. 1. 多态的分类
      1. 类的多态

abstract class Fu {

                  public abstract void method();

}

class Zi extends Fu {

public void method(){

                     System.out.println(“重写父类抽象方法”);

}

}

//类的多态使用

Fu fu= new Zi();

 

1. 1. 1. 接口的多态

interface Fu {

   public abstract void method();

}

class Zi implements Fu {

   public void method(){

        System.out.println(“重写接口抽象方法”);

}

}

//接口的多态使用

Fu fu = new Zi();

 

1. instanceof 关键字

                   格式： 对象名 instanceof 类名

                   返回值： true, false

                   作用： 判断指定的对象 是否为 给定类创建的对象

第四章

1. this关键字
   1. this关键字，本类对象的引用
      1. this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用
      2. this什么时候存在的？当创建对象的时候，this存在的
      3. this的作用：用来区别同名的成员变量与局部变量（this.成员变量）

            public void setName(String name) {

                this.name = name;

            }

1. 构造方法： 用来给类的成员进行初始化操作
   1. 格式：

        修饰符 类名 (参数列表) {

            ...

        }

1. 1. 构造方法的特点：
      1. 1, 方法名与类名相同
      2. 2，没有返回值，也没有返回值类型，连void也没有
   2. 构造方法什么时候会被调用执行？

                            只有在创建对象的时候才可以被调用

 

1. super: 指的是父类的存储空间(理解为父类的引用)

调用父类的成员变量：

super.成员变量;

                            调用父类的构造方法:

super(参数);

                            调用方法的成员方法:

super.成员方法();

1. 继承中的构造方法注意事项：

    1，如果我们手动给出了构造方法，编译器不会在给我们提供默认的空参数构造方法

           如果我们没写任何的构造方法，编译器提供给我们一个空参数构造方法

    2, 在构造方法中，默认的第一条语句为 super();

       它是用来访问父类中的空参数构造方法，进行父类成员的初始化操作

        3, 当父类中没有空参数构造方法的时候，怎么办？

            a: 通过 super(参数) 访问父类有参数的构造方法

            b: 通过 this(参数) 访问本类中其他构造方法

               注意:[本类中的其他构造方法已经能够正常访问父类构造方法]

        4, super(参数) 与 this(参数) 不能同时在构造方法中存在

第五章

1. final：关键字，最终的意思

                   final修饰的类：最终的类，不能被继承

                   final修饰的变量： 相当于是一个常量, 在编译生产.class文件后，该变量变为常量值

                   final修饰的方法： 最终的方法，子类不能重写，可以继承过来使用

 

1. static : 关键字， 静态的意思

                   可以用来修饰类中的成员(成员变量，成员方法)

                   注意： 也可以用来修饰成员内部类

1. 1. 特点：

                            被静态所修饰的成员，会被所有的对象所共享

                            被静态所修饰的成员，可以通过类名直接调用，方便

                                     Person.country = "中国";

                                     Person.method();

1. 1. 注意事项：

                            静态的成员，随着类的加载而加载，优先于对象存在

                            在静态方法中，没有this关键字

                            静态方法中，只能调用静态的成员(静态成员变量，静态成员方法

 

1. 匿名对象：一个没有名字的对象
   1. 特点：

创建匿名对象直接使用，没有变量名

匿名对象在没有指定其引用变量时，只能使用一次

匿名对象可以作为方法接收的参数、方法返回值使用

 

1. 内部类：在一个类中，定义了一个新类，这个新的类就是内部类   

                   class A {//外部类

                            class B{// 内部类

                            }

                  }

1. 1. 特点：

                            内部类可以直接访问外部类的成员，包含私有的成员

 

1. 包的声明与访问
   1. 类中包的声明格式：

package 包名.包名.包名…;

1. 1. 带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();

cn.itcast.Demo d = new cn.itcast.Demo();

1. 1. 导包的格式：

import 包名.类名;

 

1. 权限修饰符

                   public : 公共的

                   protected: 受保护的

                  

                   private : 私有的

                    public  protected   默认的   private

    在当前类中       Y       Y           Y       Y

    同一包中的其他类  Y       Y           Y

    不同包中的子类    Y       Y

    不同包中的其他类  Y

 

1. 代码块：

                   局部代码块：定义在方法中的，用来限制变量的作用范围

                   构造代码块：定义在类中方法外，用来给对象中的成员初始化赋值

                   静态代码块：定义在类中方法外，用来给类的静态成员初始化赋值

第六章

1. 不同修饰符的使用
   1. 类，最常使用public修饰
   2. 成员变量，最常使用private修饰
   3. 成员方法，最常使用public修饰
2. 自定义数据类型的使用
   1. 类作为方法参数时，说明要向方法中传入该类的对象
   2. 类作为方法返回值时，说明该方法要返回一个该类的对象。
   3. 抽象类作为方法参数时，说明要传入一个实现抽象类所有抽象方法的子类对象。
   4. 抽象类作为方法返回值时，说明需要返回一个实现抽象类所有抽象方法的子类对象。
   5. 接口作为方法参数时，说明该方法要传入一个接口实现类对象。
   6. 接口作为方法返回值时，说明该方法需要返回一个接口实现类对象。