第五章 面向对象（基础篇）

第五章   面向对象（基础篇）

一、面向对象的基本概念：封装性、继承性、多态性

二、类与对象：

          ①类：模板，共性         对象：具体，个性

          ②类的定义：       class 类名称{

       数据类型属性；  //声明成员变量

       …

       //定义方法内容

       public 返回值数据类型方法名称(参数1，参数2…){

              程序语句；

              [return 表达式；]

}

}

                                  ③对象的创建：类名对象名称 =  null；    //声明对象

                                                                             对象名称 =  new  类名()；     //实例化对象

 

类名对象名称 =  new  类名()；    //简写

所有的对象名称都在栈内存中保存（保存的实际是其对应的堆内存空间的访问地址）

                                            而对象的具体内容则保存在对应的堆内存之中，

                                           必须用new开辟堆内存空间

                          ④访问对象中的属性和方法：

                                      访问属性：对象名称.属性名

                                      访问方法：对象名称.方法名()

                          ⑤PS：     1、引用数据类型就是指一段堆内存空间可以同

                                                 时被多个栈内存指向

                                            2、引用传递：将一个堆内存空间的使用权给多

个栈内存空间，每个栈内存空间都可以修改

堆内存的内容

                                            3、一个栈内存空间只能指向一个堆内存空间，

如果要指向其他的堆内存空间，则必须先断

开已有的指向才能分配新的指向

                                           4、Java本身提供垃圾收集机制（GC）

             三、封装性：

                              ①含义：指对外部不可见

                              ②关键字：private

                              ③关于private的补充说明：

                           1、类中全部属性必须封装，封装之后的属性必

                                                    须通过setter和getter方法进行访问

                                              2、private声明的属性和方法只能在类内部调用

                                              3、调用本类中的方法，可以直接写方法名调用，

                   也可以使用“this.方法名()”强调

 

 

四、构造方法：

                 ①作用：初始化，值传递

                 ②定义格式：     class 类名称{

                                                               //无返回值声明，构造方法名与类名称一致

                                                               访问权限类名称(数据类型参数…){

                                                               程序语句；

                                                               …    //构造方法没有返回值

                                                       }

                                       }

                              ③PS：     1、调用new实例化对象时才会调用构造方法

                                              2、无明确声明时，Java在编译时会自动生成一

                                                    个无参构造方法

                                              3、已明确声明一个构造方法时，程序将不会生

                                                    成默认构造方法

                                              4、与普通方法一样，构造方法是可以重载的

             五、匿名对象

                              ①定义：没有明确地给出名称的对象

                              ②注意：       1、一般匿名对象只使用一次

                                                    2、只在堆内存中开辟空间，而不存在栈内存

                                                          的引用

                                                    3、实际开发中通常作为其他实例化对象的参

                                                          数传递

            

 

 

六、String

                              ①实例化String对象的方法

1、直接为String赋值（实质上是把一个在堆中

开辟好的堆内存空间的使用权给它，好处是当字符串内容相同时，多个名称指向同一个空间引用，不再开辟新的堆内存空间）

例：String str = “hello”;

2、用标准的new调用构造方法实例化（不管如

何都会再开辟一个新的空间，原不用空间成为垃圾空间）

例：String str = new String(“hello”);

                 ②String的比较

                                 1、地址比较：==

                                  2、内容比较：equals()

                 ③字符串的内容不可改变

                                  1、字符串的内容一旦声明则不可改变

                                  2、一个String对象内容的改变实际上是通过内

存地址的“断开-连接”变化完成的，而本身

字符串中的内容并没有任何变化

 

 

 

七、引用传递及基本应用

                 ①定义：将堆内存空间的使用权交给多个栈内存空间

                 ②在对象引用传递上也可以在一个类中接收自己本类的对

          象，而且接收完后可以方便地通过此对象直接进行本类中封装属性        的访问（此种引用方式的传递在关于对象的比较操作时才会经常使用）

 

 

八、this关键字

                 ①表示类中的属性：this.name = name;

                 ②强调调用本类中的方法：this.getInfo();

                 ③表示当前对象：Person p1 = this;

                 ④调用本类的构造方法：this(); 

1、使用this()调用构造方法必须放在构造方法的

      首行

2、程序中至少要存在一个构造方法是不用this

      调用其他构造方法的，一般都会将无参构造

      方法作为出口，即在参构造方法中最好不要

      再去调用其他构造方法

 

 

 

九、static关键字

                 ①使用static声明属性

                                  1、全局属性（静态属性）：被所有对象共享

                                  2、类属性：可以直接由类名调用

                 ②使用static声明方法

                                  1、类方法：可以直接由类名调用

                                  2、非static方法可以调用static方法，但static

                                       方法不能调用非static方法

                 ③理解main方法

                                  public：表示此方法可以被外部调用

                                  static：表示此方法可以由类名称直接调用

                                  void：主方法是程序的起点，不需要返回值

                                  main：系统规定好默认调用的方法名称

                                  String args[]：表示运行时的参数

                 ④Java中常用的内存区域

                                  1、栈内存空间：保存所以对象名称（地址）

                                  2、堆内存空间：保存每个对象具体属性内容

                                  3、全局数据域：保存static类型的属性

                                  4、全局代码域：保存所有的方法定义

 

 

 

十、代码块

                 ①定义：是指使用{}括起来的一段代码

                 ②分类：

                                  1、普通代码块：直接在方法或语句中定义，定

                                       义在其中的是局部变量

                                  2、构造块：直接在类中定义，每次实例化都会

                                       执行

                                  3、静态代码块：使用static关键字声明的，（只

                                       执行一次）

                 ③优先级：

                            静态代码块>主方法>构造块>构造方法

 

 

十一、构造方法私有化

                 ①实例化方法：在内部产生本类的实例化对象

                 ②意义：只要将构造方法私有化，就可以控制实例化对象

                   的产生（单例设计模式）

 

 

十二、对象数组

                 ①定义：包含了一组相关对象的集合

                 ②动态初始化：数组先开辟空间，使用数组的每一个对象

                   时都要分别赋值

                            Person per[] = new Person[2];

                                  per[0] = new Person(“张三”);

                                  per[1] = new Person(“李四”);

③静态初始化：

               Person per[] ={ new Person(“张三”),new Person(“李四”)};

 

 

 

十三、内部类

                 ①定义：在类的内部定义的类

                 ②声明格式：     标识符 class 外部类的名称{

                                                               //外部类的成员

                                                               标识符 class 内部类的名称{

                                                                      //内部类的成员

                                                               }；

                                                    }

                 ③优点：可以方便地访问外部类中的私有属性，代码简单

                 ④使用static定义内部类：用static声明的内部类变成了外

                   部类，但是用static声明的内部类不能访问非static的外

                   部类属性

                 ⑤在外部访问内部类：

                                  外部类.内部类内部类对象 = 外部类实例.new 内部类();

                                   生成的class文件是Outer$Inner.class的形式

                 ⑥在方法中定义内部类：在方法中定义的内部类不能直接

                   访问方法中的参数，除非参数前加上final关键字