面向对象1---封装

第一章、概述

1、封装的形式

      1.1)类:封装的是对象的属性和行为

      1.2)方法:封装的是具体的业务逻辑实现

      1.3)访问控制修饰符:封装的是访问的权限

第二章、类

第一节、类的基本介绍

1、      概述

1.1组成：类定义了一种抽象数据类型，而类不但定义了抽象数据类型的组成（成员变量），同时还定义了对该类型可以实施的操作（方法）。

1.2好处

首先：定义了Emp类以后，提升了代码的模块化以及代码的重用性

其次：实现数据和方法（对该类数据的操作）的统一，也就是说，可以将打印信息的方法也放在Emp中定义，这样方法中的变量和类中的变量实现了统一，可直接对成员变量进行操作；

最后：将功能模块化，方便管理；

1.3概念理解

类是一种引用数据类型。类为对象的模板，简单的说就是分类。

2、      使用

2.1定义一个类

2.1.1定义类的成员变量

（一）作用：“成员变量”用于描述一类对象共同的数据结构

（二）语法：修饰符  数据类型   变量名 = 变量值；

注意：修饰符可以不写；

（三）调用

对象引用.变量名；

2.1.2定义类的方法

（一）作用：用于描述对象的形为，封装对象的功能；

（二）语法

1. 返回值类型 方法名称(参数列表) {
2. 方法体………
3.     }

（三）使用---调用

其他类中通过：对象引用.方法名（有参数就传参数）；

本类中：方法名（有参数就传参数）

第二节：对象

1、 对象的概述

2、 对象的使用

2.1、声明对象

类名   引用；

引用概念：为了能够对实例化的对象进行访问控制，需一个特殊的变量，即引用。

引用工作原理：引用类型变量可以存储该类对象的地址信息，通常称为“指向该类的对象”，当一个引用类型变量指向该类的对象，就可以通过这个变量对对象实施访问。

引用类型：除8种基本类型之外，用类、接口、数组等声明的变量都称为引用类型变量，简称“引用”。

2.2创建对象（此创建对象的过程也通常称为实例化）

可以使用new关键字来创建对象。new运算的语法为： new 类名（）；

定义好类之后，可以创建该类的对象；对象创建之后，其成员变量在加载类的时候就可以按照默认的方式初始化；对象成员变量的默认初始化值规则如下图 - 5所示：

2.3赋值对象

（一）new 类名();

（二）相同类型的引用类型变量之间相互赋值

注意的是：引用类型变量之间的赋值不会创建新的对象，但有可能会使两个以上的引用指向同一个对象；简单的理解就是一个人有两个名字；每个引用操作的对象数据，都是同一个数据；

1. Emp e1 = new Emp();
2. Emp e2 = e1;  //将e1的值（对象的地址信息）赋给e2，e2和e1指向相同的对象。

（三）对其赋值为null。null的含义为“空”，表示还没有指向任何对象

注意：使用的时候必须将该引用指向一个对象，不然会报空指针异常

1. Emp emp = null;   //引用emp中的值为null，没有指向任何对象；
2. emp = new Emp();  //引用emp指向了一个Emp对象；

1． JFrame frame = null;

2． 2.frame.setSize(200,300);

第三节、方法

一、概述

方法的种类：普通方法和构造方法；

普通方法的使用：方法的重载和重写

二、方法的重载

1、意义

（1）可以降低用户的负担，用户使用不同方式去付款时不需要去找对应的窗口，只需要到同一个收款窗口就可以了

（2）减少了用户使用时的错误

（3）代码更加优雅一些。

2．代码运行相关

（1）编译器在编译时会根据方法的签名自动绑定方法

3．代码定义注意

（1）发生在同一个类中，方法名称相同，参数列表不同

三、构造方法

1．作用

对于业务：为了在创建对象的时候，就要为对应的属性设置固定值，所以需要构造方法；

对于代码：用于实现对对象成员变量的初始化：放在创建的对象的new后面；可以理解为：“new”创建了对象，而构造方法对该对象进行了初始化

2．定义

（一）规则

1. 构造方法的名称必须与类名相同。
2. 构造方法没有返回值，没有返回值类型

（二）代码格式

1. 【访问修饰符】类名(参数列表可以没有) {
2.      //构造方法体
3. }

3、使用

A、创建构造方法

任何一个类都必须含有构造方法，假如源程序中没有定义，则编译器在编译时将为其添加一个无参的空构造方法（此方法称之为“默认的构造方法”）。；但是如果自定义了构造方法，则不会创建默认的构造方法；

B、用于new后面，对对象的初始化

用于实现对对象成员变量的初始化：放在创建的对象的new后面；可以理解为：“new”创建了对象，而构造方法对该对象进行了初始化

c：构造方法的调用

使用了this关键字，在构造方法中可以通过this关键字来调用另外的一个重载的构造方法。this(row,row)调用了第一段声明Cell(int row, int col)构造方法。

4、特性

A：构造方法的重载

很多时候，为了使用的方便，可以对一个类定义多个构造方法，这些构造方法都有相同的名称（类名），只是方法的参数不同，称之为构造方法的重载

B：构造方法是可以被private修饰的，作用：其他程序无法创建该类的对象。

C：父子类中：

（1）在创建子类对象时，父类的构造方法会先执行，为什么？

因为子类中所有构造方法的第一行有默认的隐式super();语句。

（2）子类中的构造方法为什么会有一句隐式的super()呢？

原因：子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。

当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法。

5、构造方法和一般方法的区别

5.1定义格式

5.2创建方式

构造方法：如果程序员没有写，系统会默认创建一个无参构造方法；如果写了，就不会默认创建；

方法：程序员自己创建

5.3作用

构造方法：创建对象的时候，为对象初始化；

方法：需要用该方法算法的时候，由对象调用

三、方法的重写

1.方法的重写(Override):重新写、覆盖

1)发生在父子类中，方法名称相同，参数列表相同，方法体不同

2)重写方法被调用时，看对象的类型

2.4重写与重载的区别:---------面试题

1)重写(Override): 1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同 1.2)遵循"运行期绑定"，看对象的类型来调用方法 2)重载(Overload): 2.1)发生在一个类中，方法名称相同，参数列表不同，方法体不同 2.2)遵循"编译期绑定"，看引用的类型来绑定方法

第四节、变量

成员变量与局部变量的差别如下：

区别一：定义的位置不同

定义在类中的变量是成员变量

定义在方法中或者{}语句里面的变量是局部变量

区别二：在内存中的位置不同

成员变量存储在对内存的对象中

局部变量存储在栈内存的方法中

区别三：声明周期不同

成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失

局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失

区别四：初始化不同

成员变量因为在堆内存中，所有默认的初始化值

局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。

第三章、类的种类

第一节、内部类

一、概述

l  什么是内部类

将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

l  什么时候使用内部类

在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

class 汽车 { //外部类

    class 发动机 { //内部类

}

}

l  内部类的分类

内部类分为成员内部类与局部内部类。

我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

二、    成员内部类

成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

l  定义格式

class 外部类 {

    修饰符 class 内部类 {

        //其他代码

}

}

l  访问方式

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

 

l  成员内部类代码演示

定义类

class Body {//外部类，身体

    private boolean life= true; //生命状态

     public class Heart { //内部类，心脏

  public void jump() {

         System.out.println("心脏噗通噗通的跳")

            System.out.println("生命状态" + life); //访问外部类成员变量

}

}

}

访问内部类

public static void main(String[] args) {

    //创建内部类对象

    Body.Heart bh = new Body().new Heart();

    //调用内部类中的方法

    bh.jump();

}

二、    局部内部类

局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

l  定义格式

class 外部类 {

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

class 内部类 {

//其他代码

}

}

}

l  访问方式

在外部类方法中，创建内部类对象，进行访问

l  局部内部类代码演示

定义类

class Party {//外部类，聚会

    public void puffBall(){// 吹气球方法

        class Ball {// 内部类，气球

              public void puff(){

     System.out.println("气球膨胀了");

}

}

//创建内部类对象，调用puff方法

new Ball().puff();

}

}

访问内部类

public static void main(String[] args) {

    //创建外部类对象

    Party p = new Party();

    //调用外部类中的puffBall方法

    p.puffBall();

}

 

三、    内部类的实际使用——匿名内部类

1、匿名内部类概念

内部类是为了应对更为复杂的类间关系。查看源代码中会涉及到，而在日常业务中很难遇到，这里不做赘述。

最常用到的内部类就是匿名内部类，它是局部内部类的一种。

定义的匿名内部类有两个含义：

n  临时定义某一指定类型的子类

n  定义后即刻创建刚刚定义的这个子类的对象

2、定义匿名内部类的作用与格式

作用：匿名内部类是创建某个类型子类对象的快捷方式。

格式：

new 父类或接口(){

    //进行方法重写

};

l  代码演示

//已经存在的父类：

public abstract class Person{

    public abstract void eat();

}

//定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量

Person  p = new Person(){

    public void eat() {

        System.out.println(“我吃了”);

}

};

//调用eat方法

p.eat();

使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。

匿名内部类如果不定义变量引用，则也是匿名对象。代码如下：

new Person(){

    public void eat() {

        System.out.println(“我吃了”);

}

}.eat();

第四章、修饰符

一、应用

1. 
         类:
2.        权限修饰符:默认的、public
3.        状态修饰符:final
4.        抽象修饰符:abstract
5.       
6.        用的最多的就是:public
7.      
8.       成员变量:
9.        权限修饰符:private、默认的、protected、public
10. 10.        状态修饰符:static、final
11. 11.       
12. 12.        用的最多的就是:private
13. 13.       
14. 14.       构造方法:
15. 15.        权限修饰符:private、默认的、protected、public
16. 16.       
17. 17.        用的最多的就是:public
18. 18.       
19. 19.       成员方法:
20. 20.        权限修饰符:private、默认的、protected、public
21. 21.        状态修饰符:static、final
22. 22.        抽象修饰符:abstract
23. 23.       
24. 24.        用的最多的就是:public

1. 
         除此以外的组合规则:
2.        成员变量:public static final
3.        成员方法:public static
4.            public final
5.            public abstract

二、种类

限修饰符:private、默认的、protected、public

状态修饰符:static、final

抽象修饰符:abstract

1public:公开的，任何类

2protected:受保护的，本类、子类、同包类

3默认的:什么也不写，本类、同包类

4private:私有的，本类

5.static:静态的

（1）为什么需要静态

1)静态变量:

1.1)由static修饰

1.2)特性：属于类的，存储在方法区中，只有一份；某一个对象修改，其他对象的数据也变化；

1.3)如何用：常常通过类名点来访问；

1.4)何时用:所有对象所共享的资源(图片、音频、视频等)

2)静态方法:

2.1)由static修饰

2.2)属于类的，存储在方法区中，只有一份

2.3)常常通过类名点来访问

2.4)静态方法没有隐式this传递的，

静态方法中不能直接访问实例成员

2.5)何时用:方法的操作仅与参数相关而与对象无关

3)静态块:

3.1)由static修饰

3.2)属于类的，在类被加载时自动执行，因为类中被加载一次，所以静态块也只执行一次

3.3)何时用:加载/初始化静态资源(图片、音频、视频等)

 4）注意事项

4.1）静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区

4.2）同一个类中，静态成员只能访问静态成员（属性或者方法）

4.3）main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中。

6.final:最终的、不可改变的------单独应用的机率小

1)修饰变量:只能赋值一次；

引用类型的变量：值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改；

成员类型变量：需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)

2)修饰方法:方法不能被重写

3)修饰类:类不能被继承

7.static final:常量，应用率高

1)必须声明同时初始化

2)通过类名点来访问，不能被改变

3)建议:常量名所有字母都大写，多个单词用_分隔

4)编译器在编译时直接将常量替换为具体的值，效率高

8、参考链接

https://blog.csdn.net/l1585931143/article/details/52894234

第五章、代码块

a)   局部代码块

局部代码块是定义在方法或语句中

特点：

l  以”{}”划定的代码区域，此时只需要关注作用域的不同即可

l  方法和类都是以代码块的方式划定边界的

class Demo{

    public static void main(String[] args) {

        {

                 int x = 1;

                 System.out.println("普通代码块" + x);

        }

        int x = 99;

        System.out.println("代码块之外" + x);

    }

}

结果：

普通代码块1

代码块之外99

b)   构造代码块

构造代码块是定义在类中成员位置的代码块

特点：

l  优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作

l  每创建一个对象均会执行一次构造代码块。

public class Person {

    private String name;

    private int age;

   

     //构造代码块

    {

        System.out.println("构造代码块执行了");

    }

    Person(){

        System.out.println("Person无参数的构造函数执行");

    }

    Person(int age){

        this.age = age;

        System.out.println("Person（age）参数的构造函数执行");

    }

}

class PersonDemo{

    public static void main(String[] args) {

        Person p = new Person();

        Person p1 = new Person(23);

    }

}

c)   静态代码块

静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

l  它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

l  该类不管创建多少对象，静态代码块只执行一次。

l  可用于给静态变量赋值，用来给类进行初始化。

public class Person {

    private String name;

    private int age;

     //静态代码块

    static{

        System.out.println("静态代码块执行了");

    }

}