JavaSE之面向对象知识点总结

JavaSE之面向对象知识点总结

---

一、面向对象的基础

1.面向对象

  (1)Java语言:就是一种面向对象编程语言。
  (2)面向对象本质其实就是面向过程(基于面向过程)。
  (3)面向过程:代表语言，C语言。
  (4)面向对象思想特点:
    1)符合现实生活中的思想行为习惯。
    2)让我们从执行者变成了指挥者。
    3)让复杂的事情简单化。

2.面向对象的设计原则

  需要不断的创建对象,使用对象,指挥对象做事情
  举例:Scanner类:键盘录入

3.事物

  (1)定义：描述现实世界真实存在的
  (2)举例:人----事物
    长方形—事物
  (3)剖析：人
    属性:年龄,身高,性别,体重,姓名…
    行为:不断的学习…/基本的人具备的…

4.Java中最基本的单元:class 类

  (1)定义：描述现实世界一类事物的一组属性和行为的集合。
  (2)对象：对象是类的一个实例，具有状态和行为。
  (3)类与对象的关系：类是对象的抽象，对象是类的实例。
  (4)标准类的组成：成员变量、成员方法、构造方法
  (5)成员变量:现实事物的属性，定义方式与局部变量相同，只是成员变量定义在类中、方法外。
  (6)成员方法: 成员方法其实就是我们前面讲过的方法去掉static关键字。

		举例：public void study(){
				System.out.println("人都需要学习...") ;
	  		  }

  (7)创建对象的格式:
    类名 对象名 = new 类名() ;
  (8)成员变量的调用与赋值 :
    对象名.成员变量= 值;
  (9)成员方法的调用:
    对象名.成员方法名() ;

5.类的组成及其可以用的修饰符

  (1)类：
    默认，public，final，abstract
    自己定义：public居多
  (2)成员变量：
    四种权限修饰符均可,final,static
    自己定义：private居多
  (3)构造方法：
    四种权限修饰符均可,其他不可
    自己定义：public 居多
  (4)成员方法：
    四种权限修饰符均可，fianl,static,abstract
    自己定义：public居多

6.成员变量和局部变量的区别

  (1)书写位置不同
    成员变量:在类中,方法外定义的变量。
    局部变量:在方法声明上或者是方法定义中。
  (2)内存中的位置不同
    成员变量:在堆内存中。
    局部变量:在栈内存中。
  (3)生命周期不同
    局部变量:随着方法调用而存在,随着方法调用完毕而消失。
    成员变量:随着对象的创建完毕而存在,随着对象被GC回收掉而消失。
    对象的回收:并不是立即回收,而是等待垃圾回收器空闲时回收掉。
  (4)初始化不同
    成员变量:可以不进行初始化,因为它在堆内存中(跟对象有关系),存在系统默认初始化。
    局部变量:必须在使用之前对象局部变量进行初始化,否则报错。

7.静态变量与成员变量的区别

  (1)所属不同
    静态变量属于类，所以也称为为类变量 。
    成员变量属于对象，所以也称为实例变量(对象变量) 。
  (2)内存中位置不同
    静态变量存储于方法区的静态区 。
    成员变量存储于堆内存 。
  (3)内存出现时间不同
    静态变量随着类的加载而加载，随着类的消失而消失 。
    成员变量随着对象的创建而存在，随着对象的消失而消失 。
  (4)调用不同
    静态变量可以通过类名调用，也可以通过对象调用。
    成员变量只能通过对象名调用。

8.代码块

  (1)定义：使用{}包起来的内容,就称为代码块。
  (2)分类:
    1)局部代码块：在方法中定义的{}。
      作用:限定变量的生命周期，及早释放，提高内存利用率。
    2)构造代码块：在类中的成员位置定义{}。
      特点:每次执行构造方法之前先执行构造代码块。
      作用:多个构造方法中相同的代码存放到一起执行。
    3)静态代码块：在{}的前面加上static
      作用：用于给类初始化。
      特点：静态代码块随着的类的加载而加载,由于类加载一次,静态代码块执行一次。
  (3)优先级:静态代码块 > 构造代码块 >构造方法

9.成员方法的分类

  是否有返回值：有具体返回值类型的方法和没有具体返回值类型的方法。
  是否有形参：有形参的方法和没有形参的方法。

10.构造方法

  (1)特点:
    1)方法名和类名相同
    2)没有具体的返回值类型
    3)连void都没有
  (2)格式：
    无参构造方法：
      权限修饰符 方法名和类名相同(){
      }
    有参构造方法：
      权限修饰符 方法名和类名相同(参数列表){
        为成员变量赋值…
      }
  (3)作用:给对象的成员变量进行数据初始化。
  (4)构造方法的重载:无参构造方法，有参构造方法。
  (5)注意事项:
    1)在写一个类的时候,如果没有提供无参构造方法,系统默认提供无参构造方法。
    2)如果开发者提供有参构造方法,系统不会提供无参构造方法了,需要开发者给出无参构造方法。

11.对象的初始化过程

假设创建一个学生类对象Student s = new Student();
  在内存中的创建过程：
    (1)加载Student.class文件进内存 。
    (2)在栈内存中为引用s开辟空间 。
    (3)在堆内存中为学生对象开辟空间 。
    (4)对学生对象的成员变量进行默认初始化 。
    (5)对学生对象的成员变量进行显示初始化 。
    (6)通过构造方法对学生对象的成员变量赋值 。
    (7)学生对象初始化完毕，把对象地址赋值给s变量。

---

二、面向对象中的关键字

1.this

  (1)定义：代表当前类对象的地址值引用。
  (2)使用：
    this.成员变量;访问当前对象的成员变量
    this.成员方法名() ;访问当前对象的成员方法
    this() :访问的是本类无参构造方法
    this(xxx):访问的本类的有参构造方法

2.super

  (1)定义：代表父类存储空间的标识(可以理解为父类引用)
  (2)使用：
    super.成员变量;访问的父类的成员变量
    super.成员方法名() ;访问的是父类的成员方法
    super():访问的是父类的无参构造方法
    super(xxx):访问的父类的有参构造方法

3.this和super的区别

  this:代表当前类的对象地址值引用
  super:代表父类的空间标识(父类对象的地址值引用)
  this调用成员或构造方法，访问的都是当前类的成员或构造方法。
  super调用成员或构造方法，访问的都是父类的成员或构造方法。

4.private

  (1)概念：私有的。
  (2)作用：它可以修饰成员变量,也可以修饰成员方法。
  (3)应用：是实现封装的基础。
  (4)特点：被private修饰的成员只能在本类中访问，外界不能访问。只能通过提供的公共访问方法进行访问。

5.static

  (1)概念: 静态的
  (2)修饰属性：类.属性–所有对象都共享的
    1)生命周期：
      创建：类加载时，会把类里所有的静态属性都放在静态常量区中。
      销毁：整个项目结束时，才会被销毁。
    2)注意：此属性用类名直接调用
    3)应用场景：static + final
  (3)修饰方法:类.方法------直接用类名调用
    应用场景：工具类
  (4)静态代码块

6.static关键字的特点

  (1)被static修饰的成员,随着类的加载而加载，且只加载一次。
  (2)优先于对象存在：对象的创建是在类加载的后面。
  (3)被static修饰的方法或者变量可以被该类的所有对象共享。
  (4)被static修饰的变量以及方法可以被类名直接访问，也可以通过对象名来访问。

7.static的注意事项

  (1)static关键字修饰的方法中没有this关键字。
  (2)关于访问的问题:
    非静态的成员方法,既可以访问静态的成员,也可以访问非静态的成员；
    静态的方法只能静态的成员。

8.final

  (1)定义：表示最终的,终态的,无法更改的。
  (2)作用：
    修饰类：该类不能被继承。
    修饰变量：这个变量会成为一个常量(自定义常量)，且只能被赋值一次。
    修饰方法：该方法不能被重写。
  (3)final修饰基本类型变量和引用类型变量的区别
    基本数据类型:它的数据值不能再改变。
    引用数据类型:它的地址值不能再改变,但它的成员变量值是可以改变的。

9.abstract

  (1)概念:抽象的意思
  (2)作用：
    修饰类：抽象类
    修饰方法：抽象方法

10.不能与abstract共存的关键字

  (1)不能和final一块使用
    final修饰成员方法:方法不能被重写。
    abstract修饰的方法:子类必须重写。
  (2)不能和private一块使用
    private私有化，只能在本类中访问。
  (3)不能和static一块使用
    被static修饰的方法直接使用类名调用。
    但是抽象方法又需要让子类重写，静态方法算不上方法重写。

11.访问权限修饰符

  权限修饰符分类及定义
    private:私有的
    默认修饰符:不加入任何修饰符
    protected:受保护的
    public:公共的,访问权限最大

修饰符	本类	同包子类/同包无关类	不同包子类	不同包无关类
private	Y	N	N	N
默认修饰符	Y	Y	N	N
protected	Y	Y	Y	N
public	Y	Y	Y	Y

---

三、面向对象的三大特征——封装

  概念：将一个类的某些成员私有化,使外界不能够直接访问,只能通过一些公共的方法间接的访问。
  优点：
    隐藏具体的实现细节，提供公共的访问方式；
    提高了代码的复用性；
    提高安全性。
  原则：将不需要对外提供的内容都隐藏起来。

---

四、面向对象的三大特征——继承

1.继承

  (1)概念：将一些类似的类的共性内容抽取出来，定义在单独的一个类中，他们和这个类产生的关系。
  (2)实质体现：一种"is a"的关系,即A类是B类的一种或者B类是A类的一种。
  (3)语法：class 子类 extends 父类{}
  (4)名词解释：父类：被继承的类，也成基类或者超类。
        子类：继承的类，也称派生类。
  (5)应用：产生继承关系后，子类可以使用父类的属性和方法，也可定义子类独有的属性和方法。
  (6)好处：提高了代码的复用性和可扩展性,是多态的前提条件。
  (7)特点：java的继承为单继承，一个类只能有一个直接父类，但可以有多级继承。

2.继承中访问子父类成员的特点

  (1)访问成员变量
    1)子类中和父类中成员变量名称不同:分别访问即可。
    2)子类中和父类中成员变量名称相同:遵循"就近原则"。
      从子类局部位置到成员位置，再到父类成员位置。如果找到就使用，找不到就逐级向上查找；如果直到父类成员位置都没找到，就报错。
  (2)继承中访问成员方法
    1)成员方法名称不同:分别访问即可。
     2)成员方法名称相同:先在子类中找是否存在这个方法，如果子类找不到这个方法,就在父类中找,如果父类中都找不到,就报错。
  (3)继承中访问构造方法
    1)可以通过super间接访问父类的构造方法。
    2)子类的所有构造方法默认访问父类的无参构造方法。
    3)访问父类无参构造的原因：为子类对象初始化父类数据。

3.分层初始化

  由于存在继承关系,创建子类对象时,先要执行父类构造，进行父类属性的初 始化,在执行子类构造，进行初始化。

4.继承中的注意事项

  (1)不能继承父类的私有的成员(成员变量,成员方法)。
  (2)不能够继承父类的构造方法,但可以通过super关键字,来间接访问。
  (3)子父类不在同一个package中时，default修饰的属性和方法，子类无法访问。
  (4)子类的构造方法中第一句话默认存在”super();”可以不写。
  (5)子父类在内存中的加载顺序：先加载父类,再加载子类。
  (6)当类中只有无参构造，可以不写，系统会自动提供。
  (7)当类中有有参构造，系统不提供无参构造，需要开发者自行编辑。
  (8)当父类中有有参构造，却没有无参构造，程序会报错；需要手动为父类添加无参构造，或者让子类构造都调用父类的有参构造。

5.方法重写

  (1)概念：子类中出现了和父类中一模一样的方法。
  (2)场景:当父类提供的方法无法满足子类需求时，可以在子类中定义和父类相同的方法进行重写。
  (3)原则：方法名、参数列表、返回值类型都必须与父类的相同，访问修饰符不能比父类更严格。
  (4)注意：子类重写父类方法后，调用时优先执行子类重写后的方法。

6.重载(Overload) 和重写(Override)的区别

  (1)方法重写存在于具有继承关系的子类中。
  (2)方法的重载存在于一个类中。
  (3)方法重写：方法名、参数列表、返回值类型都必须与父类的相同，访问修饰符不能比父类更严格。
  (4)方法重载：方法名相同、参数列表不同、与访问修饰符和返回值类型无关。

---

五、面向对象的三大特征——多态

1.多态

  (1)定义：一个事物在不同时刻表现出的不同状态。
    举例:
      水：固态,液体,气态
      动物类: 猫/狗都是动物
  (2)前提条件
    1)必须存在继承关系。
    2)要有方法重写
    3)需要存在:父类引用指向子类对象

2.多态的成员访问特点

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

  (1)成员变量：编译看左,运行看左边。
  (2)成员方法：编译看左边,运行看右(因为存在方法重写)。
  (3)静态的成员方法:编译看左,运行看左。
    子类出现了和父类一摸一样的静态方法,静态方法跟类相关,不存在重写。
    访问方式:类名.方法名();
  (4)构造方法:分层初始化

3.多态的优缺点

  (1)优点：
    1)提高了代码的扩展性(由多态)
    2)提高了代码的复用性,维护性(由继承关系保证)
  (2)弊端:不能够访问子类的特有功能。
    解决方法：
      方式1:创建子类具体类对象:
        子类名 对象名 = new 子类名() ;
        对象名.访问子类自己的功能;
        从内存角度考虑,在堆内存中产生一个内存空间，比较消耗 内存空间。
      方式2:向上转型
        Fu f = new Zi() ;
        向下转型
        Zi z = (Zi)f;
        不需要重新new对象,堆内存中节省内存空间。

4.多态中的转型

  (1)前提条件:要使用向下转型,必须先使用向上转型。
  (2)向上转型：父类引用指向子类对象
    格式：父类名 引用名=new 子类名();
  (3)向下转型:将父类的引用强制转换为子类的引用。
    格式：子类名 引用名 = (子类名)父类引用;
  (4)注意事项:多态中向下转型使用不当,程序出现异常。
    ClassCastException:运行时期异常(RuntimeException)的一种
    出现原因：使用向下转型的时候类型不匹配导致的。
    规避该异常：向下转型前，应该判段引用中的对象真实类型，保证类型转换的正确性。
    使用instanceof关键字：
      if(父类引用 instanceof 类型){
      }

---

六、面向对象中的引用类型

1.抽象类

  (1)定义：在一个类中,将某个功能只给出一个声明(抽象方法),那么该类定义为抽象类。
  (2)抽象类格式：权限修饰符 abstract class 类名{}
  (3)抽象方法:没有方法体的方法
    格式：权限修饰符(public) abstract 返回值类型 方法名() ;
  (4)抽象类多态:父类引用指向子类对象
    格式:父类名 对象名 =new 子类名() ;
  (5)本质:强制子类必须完成的事情。

2.抽象类的成员特点

  (1)成员变量:既可以定义常量,也可以定义变量。
  (2)成员方法:即可定义抽象方法,也可以定义非抽象方法。
  (3)构造方法:对父类中的数据进行初始化，不能创建对象。

3.抽象类的注意事项

  (1)抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
  (2)抽象类中不一定全是抽象方法,也可以有非抽象方法。
  (3)抽象类不能直接实例化,需通过具体的子类进行实例化。
  (4)继承抽象类的子类必须重写父类所有抽象方法，否则该类必须声明为抽象类。
  (5)抽象类的子类:
    子类是具体类,直接以抽象类多态的形式实例化。
    子类是抽象类,应该还要提供更最具体的子类,否则都无法实例化。
  (6)在抽象类中定义抽象方法的时候,必须使用abstract修饰符不能省略。
  (7)定义抽象方法时只能使用public /protected权限修饰符修饰。
  (8)抽象类多态的访问成员特点与具体类多态访问特点相同。
  (9)将一个类定义为抽象类的意义在于，让其不能直接实例化。

4.接口

  (1)概念：是一种能力和约定。
  (2)格式：
    interface 接口名{
      …
    }
  (3)应用：当父类的方法种类无法满足子类需求时，可以实现接口扩充子类能力。
  (4)接口实例化
    接口多态：接口不能直接实例化 ,需要通过接口引用指向实现类对象。
    格式:接口名 对象名 =new 子实现类名() ;
  (5)开发中接口的命名格式
    命名格式:
      接口名：XXXDao
      接口子实现类:接口名的后面+Impl

		举例：
			用户接口
			UserDao:(dao---->Data Access Object :数据访问对象)
			用户接口实现类
			class UserDaoImpl  implements UserDao{
				....
			}

5.注意事项

  (1)接口中的方法只能是抽象方法,不能有方法体。
  (2)接口的命名规则:多个单词，遵循"大驼峰命名法"。
  (3)类实现接口时，必须实现接口中所有抽象方法，否则此类为抽象类。
  (4)实现接口中的抽象方法时，访问修饰符必须是public。
  (5)接口多态的访问成员特点与具体类多态访问特点相同。

6.接口的成员特点

  (1)属性: 只能是常量,默认被public static final修饰(可以省略不写)。
  (2)成员方法:只能是抽象方法,默认被public abstract修饰(可以不写)。
  (3)构造方法:接口没有构造方法

7.接口的优点

  (1)降低程序的耦合度；
  (2)更自然的使用多态；
  (3)设计与实现完全分离；
  (4)更容易搭建程序框架;
  (5)更容易更换具体实现。

8.类、接口的关系

  (1)类与类之间：继承关系,只支持单继承,不支持多继承,但是可以多层继承。
  (2)类与接口之间：实现关系,一个类在继承另一个类的同时,可以实现多个接口。
  (3)接口与接口之间：继承关系,可以单继承,也可以多继承。

9.抽象类和接口的区别

  (1)成员的区别
    抽象类:
      属性:既可以定义常量,也可以变量。
      成员方法:既可以是抽象方法,也可以是非抽象方法。
      构造方法:存在无参构造/有参构造,对数据进行初始化。
    接口:
      属性：只能是常量。
      成员方法:只能是抽象方法
      构造方法:不存在构造方法
  (2)关系的区别:
    类与类之间:单继承,不支持多继承,但是可以多层继承。
    类与接口:实现关系，一个类继承另一个类的同时,可以实现多个接口。
    接口与接口:继承关系:extends，可以单继承,也可以多继承。
    (3)设计理念的区别
      抽象类:由继承来保证代码的复用性,由多态来保证代码的扩展性。体现一种"is a"的关系。
      接口:是一种额外的功能,体现的是一种"like a"的关系。

10.内部类

  (1)概念：在A类中定义一个B类,就将B类称为A类的内部类;将A类称为B类外部类。
  (2)内部类的分类:
    1)成员内部类:在类的成员位置定义的类。
    2)局部内部类:在局部位置中定义的类。
  (3)注意事项：
    1)外部类和内部类之间是没有继承关系的。
    2)当内部类与外部类的变量名相同时，可以使用外部类的this调用外部类变量:外部类名.this.变量。

11.内部类的成员访问特点

  (1)成员内部类的成员访问特点：
    1)内部类的成员可以直接访问外部类的成员包括私有。
    2)外部类的成员向访问成员内部类的成员的时候,不能直接访问,要通过内部类对象访问。
    3)访问外部类中的成员内部类的成员方法，访问方式:
      1)前提条件:就是当前成员内部类是非静态的。
      2)固定格式:
        外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        举例：Outer3.Inner3 oi = new Outer3().new Inner3() ;
  (2)静态成员内部类访问特点：
    1)将静态的成员内部类看成是外部类的静态成员。
    2)静态的成员内部类的成员方法,只能访问外部类的静态成员。
    3)访问外部类的静态成员内部类的成员方法,访问方式:
      外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
    4)访问外部类的静态成员内部类的静态成员方法,访问方式:
      外部类民名.内部类名.静态成员方法名();
  (3)局部内部类的成员访问特点：
    1)局部内部类的成员方法可以直接访问外部类的成员,包括私有的。
    2)外部类访问局部内部类：在当前外部类的成员方法中,创建内部类对象调用它的方法。
    3)局部内部类访问外部类的局部变量：
      Jdk7之前（包括jdk7）需要开发者手动使用final修饰局部变量。

			原因：
			局部变量的生命周期:随着方法调用而存在,随着方法调用完毕而消失。
			由于当前局部内部类中的成员方法还在使用局部变量,间接通过在外部类的成员方法中创建内部类对象。
			调用内部类的成员方法，访问局部变量,对象不会立即被回收,需要等待GC空闲时候回收。
			内部类的成员方法还在访问,需要将当前局部变量定义为常量，存储在静态区中。
			Jdk8开始默认存在，不用添加final。

12.匿名内部类

  (1)概念：它是内部类的一种简化格式，没有具体类名
  (2)格式:
    new 类名(抽象类类名)/接口名(){
      重写方法…
    };

		举例:
			new Person(){  //Person:抽象类   
				//重写方法
				public void love() {
					...
				}
			} ;

  (3)本质:就是一个继承该抽象类或者实现了该接口的子类匿名对象。

13.匿名对象

  (1)概念:没有名字的对象。
  (2)格式: new 类名();
  (3)特点:
    1)可以作为形式参数传递。
    2)一个匿名对象只能使用一次。
    3)匿名对象创建完毕,使用完毕就立即被回收(节省内存空间)
  (4)应用场景:移动端(android)大量去使用匿名对象或者匿名内部类。

14.方法的形参是引用类型

  (1)具体类：需要传递该具体类的对象。
  (2)抽象类：实际参数需要该抽象类的子类对象。
  (3)接口：实际参数需要该接口子实现类对象。

15.方法有具体返回值类型

  (1)基本数据类型:四类八种，需要返回该基本类型的数据值。
  (2)引用数据类型:数组,类,接口
    具体类:需要返回(return)该具体类的对象。
    抽象类:需要返回该抽象类的子类对象。
    接口:需要返回该接口的子实现类对象。

---

七、提及的知识

1.Java中的开发原则

  (1)原则：低耦合,高内聚
  (2)耦合:类与类之间的关系,越少越好。在开发中尽可能降低程序间的耦合度。
  (3)内聚:完成某个事情，在一个类中能完成的,尽量一个类中完成。

2.选择排序

  (1)思想:使用数组中0角标对应的元素依次和后面元素进行比较,小的值往前放,第一次比较完毕,最小值出现在最小索引处,依次这样比较。
  (2)规律:比较的次数:数组长度-1次
  (3)代码实现：

		for(int x = 0 ; x < arr.length-1 ;x ++) {//x=0,1,2,3
			for(int y = x +1 ; y < arr.length ; y ++) {
				if(arr[y] < arr[x]) {
					int temp = arr[x] ;
					arr[x] = arr[y] ;
					arr[y] = temp ;
				}
			}
		}

3.eclipse中的常用快捷键

快捷键	作用
alt+/	代码提示
cltr+shift+/	将多行代码注释掉
cltr+shift+| 取消多行注释
ctlr+/	单行注释/取消单行注释
alt+sift+s–>c	创建无参构造方法
alt+shift+s–>o	创建有参构造方法
alt+shift+s–>r	提供setXXX(Xx xx)/getXXX
ctlr+d	删除某一行代码
ctrl+shift+o	导包的快捷键
ctrl+1/ctlr+2+l(字母)	创建对象的时候使用,自动补全代码
alt+shift+s—h	重写toString()方法

4.文档说明书的制作

  (1)定义工具类
  (2)无参构造方法私有化,外界不能创建该类对象,里面所有的功能全都是static的 。
  (3)在工具类中,对所有的功能加入文档注释。
  (4)针对工具类文件产生一个文档说明

		打开dos--->进入到工具类所在目录中
		javadoc -d  目录名 -author -version 工具类名.java

5.包

  (1)概念：文件夹(目录)
  (2)包的命名规则:公司域名反写,中间.或者_隔开，字母全部小写。
    单级包：com
    多级包：com.xxxxx.user
  (3)注意：以后在开发中,通过包来划分结构
    按照模块划分

			用户模块:针对用户的增删查改
			com.xxxx.user
			订单模块:com.xxxx.order

    按照功能划分

			用户的添加功能：com.xxxx.user.add
			修改功能：com.xxxx.user.update 

6.带包的类的编译运行过程

  同一个包下：
    (1)手动方式
      1)编译当前文件：javac 类名.java
      2)手动建立包对应的文件夹。
      3)把编译产生的class文件放到建立的文件夹中。
      4)带包名运行字节码文件:java 包名.类名
    (2)自动方式
      1)加入-d编译：javac -d . 类名.java
      2)带包名运行字节码文件：java 包名.类名
  不同包下：
    (1)先编译被导入的类
      javac -d . 导入类的类名.java
    (2)编译当前类
      javac -d . 当前类的类名.java
    (3)运行当前类
      java 当前类的包名.当前类的类名
  注意：
    导包：不同包下的类之间的访问，需要导包。
    格式：import 包名;
    优先级：pakcage>import>class

---

总结

  本文主要从面向对象的基础、面向对象中的关键字、面向对象中的引用类型、面向对象的三大特征——封装、继承和多态等方面总结了JavaSE面向对象部分的知识点。