黑马程序员——java学习3(62-83)——面向对象——封装

1、面向对象

三大特性：封装、继承、多态

面向过程-想到啥做啥

面向对象-整体化分析，再分块制作。

发生变化时，面向过程可能要推倒重做，面向对象则可以适应变化

1.1封装：Encapsulation

(1)把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单位（对象）中。

(2)把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知道，或只允许使用对象的功能，而尽可能隐蔽对象的功能实现细节。

另一个特点，为封装在一个整体内的变量及方法规定不同级别的“可见性”或访问权限

1.2继承：

(1)提高代码复用性，提高开发效率。

(2)首先拥有反映事物一般特性的类，然后再其基础上派生出反映特殊事物的类。

(3)若子类只允许继承一个父类，则称为单继承；若允许继承多个父类，则称为多继承。java通过接口(interface)的方式来弥补因java不支持多继承而带来的子类不能想用多个父类的成员的缺点。

1.3多态性：

允许程序中出现重名现象。使程序的抽象程度和简洁程度更高，有助于程序设计人员对程序的分组协同开发。

(1)方法重载

(2)对象多态，子类对象与父类对象进行相互转换，而且根据其使用的子类的不同，完成的功能也不同。

PS:面试关于对象

面试官需要寻找具有专业编程功能的人来完成公司工作

我就是那个对象，具备这个功能

你就是在指挥我，就是在使用我的专业技能

当然，我不禁具备专业编程技能，还会一些更多的。

一切皆对象，万物皆对象。

2、多个引用指向同一个对象，一变全变。

3、成员变量和局部变量

成员变量作用于整个类，

局部变量作用于函数中，或语句中。

成员变量在堆内存中，因对象存在而存在

局部变量，栈内存

4、匿名对象

new Car().num=5;//执行完变垃圾

new Car().color="blue";//执行完变垃圾

new Car().run;

使用方式

(1)当对对象的方法只调用一次时可用，较简化。

　　若对一个对象进行多个成员调用，必须给对象起名字

(2)可将匿名对象作为实际参数进行传递

且调用过后，会自动变为垃圾，释放内存

5、封装

5.1、私有private(仅是封装的一种形式)

权限修饰符，用于修饰类中的成员（成员变量，成员函数）

私有只在本类中有效

可提供方法来访问，在方法中加判断等语句。

提高代码的健壮性

6、构造函数

作用：对象的初始化(没写的话都自带空参数的构造函数)

多个构造函数是以重载的形式存在

6.1、构造函数与一般函数比较

构造函数在对象已建立就运行，给对象初始化。                    只运行一次

一般函数是对象调用才执行，给对象添加其具备的功能。         可调用多次

7、构造代码块

{}//没函数名

作用: 给对象初始化

对象一建立就运行，优先于构造函数。

区别: 构造代码块是对所有对象进行统一初始化，

而构造函数是给对应的对象初始化。

8、this关键字

8.1、哪个对象调用this所在的函数，this代表哪个对象

定义类功能时，该函数内部要用到该函数的对象时，这时用this来表示这个对象

package learn;

class Person{
    private String name;
    private int age;
    Person(int age)
    {
        this.age=age;
    }
    public void speak(){
        System.out.println("name="+name+"...age="+age);
    }
    public boolean compare(Person p)
    {
        return this.age==p.age;//相当于p1.age==p2.age;
    }
}

public class PersonDemo3 {
    public static void main(String[] args){
        Person p=new Person(40);
        Person p2=new Person(20);
        System.out.print(p.compare(p2));
    }

}

8.2、构造函数之间调用，可用this

不过this()语句需要放在第一行。即初始化动作需要第一行执行，有更细致的初始化则使用更细致的。

9、静态static

修饰符，用于修饰成员(成员变量，成员函数)，共性变量,存放于方法区

调用方式+1: 类名.静态变量

9.1特点

(1)随着类的加载而加载，随着类的消失而消失即生命周期长(弊端1)

(2)优先于对象存在

(3)被所有对象共享(利处2)

(4)可以直接被类名调用（利处3）

9.2、类变量和实例变量

类变量随着类的加载而存在于方法区中(利处1)

实例变量随着对象的建立而存在于堆内存中

9.3、静态方法

静态方法只能访问静态成员，不可用this,super关键字。(弊端2)

ps:相当于有了类名.

9.4、main函数

main不是关键字，只是可被jvm识别的特殊单词

public static void main(String[] args)唯一可改args

传入的是new String[0]

package learn;

public class MainDemo {
    public static void main(String[] args)
    {
        String[] arr={"hah","hehe","heihei","xixi","hiahia"};
        MainTest.main(arr);
    }
}
class MainTest{
    public static void main(String[] args)
    {
        for(int x=0;x<args.length;x++)
        {
            System.out.println(args[x]);
        }
    }
}

9.5何时使用静态

共享数据--静态变量

功能内部没有访问到非静态数据--静态方法

工具类私有化，包括构造函数都私有化，只通过类名调用。

10、调用他人的class时，记得设置classpath=.;cclass;（记得保留当前路径）

11、文档

必须为public类

javadoc -d myhelp -author -version ArrayTool.java

　　　　生成处的文档名 作者，版本号可不加 文档依据的源文件

index文件开始查看

12、静态代码块

随着类的加载而执行，只执行一次，用于给类初始化，无法含有非静态内容,优先于主函数

package learn;//执行结果 ac9d

class StaticCode{
    int num=9;
    StaticCode()
    {
        System.out.println("b");
    }
    
    static{
        System.out.println("a");
    }
    
    {
        System.out.println("c"+num);
    }
    
    StaticCode(int x)
    {
        System.out.println("d");
    }
    
    public static void show(){
        System.out.println("show run");
    }
}

public class StaticCodeDemo{
    public static void main(String[] args){
        new StaticCode(4);
    }    
}

13、执行顺序

1、因new用到了Person.class，所以会先找到Person.class文件并加载到内存中。

2、执行该类中的static代码块

3、在堆内存中开辟空间，分配内存地址。

4、在堆内存中建立对象的特有属性，并进行默认初始化。

5、对属性进行显式初始化

6、对对象进行构造代码块初始化

7、对对象对应的构造函数初始化

8、将内存地址赋给栈内存的p变量。

14、单例模式-一个类中只存在一个对象

14.1特点

(1)禁止其他程序建立该类对象--将构造函数私有化

(2)让其他程序能访问该类对象--类中创建一个本类对象

(3)方便其他程序对对象的访问--可以对外提供一些访问方式（只有这个进出口）

保证对象在内存中唯一才用到

饿汉式:

Single类一进内存就已经创建好了对象

package learn;

class Single{
    private int num;
    public void setNum(int num)
    {
        this.num=num;
    }
    public int getNum()
    {
        return num;
    }
    private Single(){}
    private static Single s=new Single();
    public static Single getInstance(){
        return s;
    }
}
public class SingleDemo {
    public static void main(String[] args)
    {
        Single s1=Single.getInstance();
        Single s2=Single.getInstance();
        s1.setNum(40);
        System.out.print(s2.getNum());
    }
}

懒汉式:

Single类进内存，对象还不存在，只在调用了getInstance方法时，才建立对象.

package learn;
class Single2{
    private static Single2 s=null;
    private Single2(){};
    public static Single2 getInstance(){
        if(s==null)//此处两条语句执行，容易因cpu多线程导致报错。具体解决见多线程。故除面试外，多用饿汉式
            s=new Single2();
        return s;
    }
}
public class SingleDemo2 {
    public static void main(String[] args){
        Single2 s2=Single2.getInstance();
    }
}