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

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

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来表示这个对象

 1 package learn;
 2 
 3 class Person{
 4     private String name;
 5     private int age;
 6     Person(int age)
 7     {
 8         this.age=age;
 9     }
10     public void speak(){
11         System.out.println("name="+name+"...age="+age);
12     }
13     public boolean compare(Person p)
14     {
15         return this.age==p.age;//相当于p1.age==p2.age;
16     }
17 }
18 
19 public class PersonDemo3 {
20     public static void main(String[] args){
21         Person p=new Person(40);
22         Person p2=new Person(20);
23         System.out.print(p.compare(p2));
24     }
25 
26 }

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]

 1 package learn;
 2 
 3 public class MainDemo {
 4     public static void main(String[] args)
 5     {
 6         String[] arr={"hah","hehe","heihei","xixi","hiahia"};
 7         MainTest.main(arr);
 8     }
 9 }
10 class MainTest{
11     public static void main(String[] args)
12     {
13         for(int x=0;x<args.length;x++)
14         {
15             System.out.println(args[x]);
16         }
17     }
18 }

 

9.5何时使用静态

共享数据--静态变量

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

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

 

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

 

11、文档

必须为public类

javadoc -d myhelp -author -version ArrayTool.java

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

index文件开始查看

 

12、静态代码块

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

 1 package learn;//执行结果 ac9d
 2 
 3 class StaticCode{
 4     int num=9;
 5     StaticCode()
 6     {
 7         System.out.println("b");
 8     }
 9     
10     static{
11         System.out.println("a");
12     }
13     
14     {
15         System.out.println("c"+num);
16     }
17     
18     StaticCode(int x)
19     {
20         System.out.println("d");
21     }
22     
23     public static void show(){
24         System.out.println("show run");
25     }
26 }
27 
28 public class StaticCodeDemo{
29     public static void main(String[] args){
30         new StaticCode(4);
31     }    
32 }

 

13、执行顺序

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

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

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

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

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

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

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

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

 

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

14.1特点

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

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

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

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

饿汉式:

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

 1 package learn;
 2 
 3 class Single{
 4     private int num;
 5     public void setNum(int num)
 6     {
 7         this.num=num;
 8     }
 9     public int getNum()
10     {
11         return num;
12     }
13     private Single(){}
14     private static Single s=new Single();
15     public static Single getInstance(){
16         return s;
17     }
18 }
19 public class SingleDemo {
20     public static void main(String[] args)
21     {
22         Single s1=Single.getInstance();
23         Single s2=Single.getInstance();
24         s1.setNum(40);
25         System.out.print(s2.getNum());
26     }
27 }

懒汉式:

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

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