黑马程序员_面向对象1

----------------------android培训、java培训、期待与您交流！ ----------------------

1.什么是面向对象

         使用对象变成，它有三大特征：继承，封装，多态

2.什么是对象

         使用类创建的一个实例就是对象，一个类可以创建多个实例，每一个实例就是这个类的对象

         eg:小明就是人这个类的一个对象

3.什么是类

         类是用来描述一类事物的，可以理解为一类事物的设计图

         例如：商品，电脑，人。。。

4.怎么用类描述事物

         在类中使用变量描述事物的特征（成员变量）

         在类中使用方法描述事物的行为（成员方法）

[java]  view plain copy

1. <span style="font-size:14px;">class Person {  
2.                    Stringname; //人有姓名这个属性  
3.                    publicvoid speak() //人有说话这个行为  
4.                    {  
5.                             System.out.println("Iam "+name);  
6.                    }  
7.          }</span>  

5.怎么创建对象

         使用new 类名()形式创建对象（内部调用了构造函数）

         eg:Pesonp = new Person();

6.怎么使用对象

         创建对象后，使用变量引用对象

         通过"变量.变量名"的方式访问对象中的特征

         通过"变量.方法名"的方式调用对象中的行为,

         在成员方法中可以访问自己的成员变量.

7.成员变量的默认值

         类中的成员变量和数组元素一样, 是可以有默认值的

         当创建一个对象之后, 如果没有给成员变量赋值, 那么这些成员变量会默认初始化为默认值

         基本数据类型的默认值都是0,引用数据类型的默认值都是null,char类型默认为:' '

8内存原理

         Person p = new Person()

         类空间: 当第一次使用Person类的时候, 加载当该类

         堆内存: 创建对象, 初始化成员变量

         栈内存: 创建了变量p, 引用了对象的地址

9对象的生命周期

         生命周期开始: 创建对象的时候.

         生命周期结束: 没有任何引用指向该对象的时候, 该对象成为垃圾对象. 当内存中垃圾对象较多时, 就会自动清理

10.匿名对象

         创建对象之后, 不用任何变量引用就叫匿名对象.

         匿名对象只能使用一次, 使用之后立即成为垃圾对象.

        new Person.speak();

11.构造函数

         构造函数是一个特殊的函数,它没有返回值类型, 函数名和类名一致, 创建对象的时候自动调用

         通常我们在创建对象的时候,需要做一些事情, 这些事情就放在构造函数中去做.

         在构造函数的第一条语句, 使用"this(参数列表)"可以调用当前类的其他构造函数.

         一个类如果没有写任何构造函数, 在编译的时候, 会自动生成一个无参的(隐式的构造函数), 其中什么代码都没有.

         如果在类中定义了一个有参构造函数, 那么就不会生成无参的了, 这时无法使用无参构造函数创建对象.

         如果在定义有参构造函数之后,还希望可以调用无参的构造函数, 那么就必须显式地定义一个无参构造函数

12.this关键字

         a.当作引用

                            在方法中的局部变量和成员变量同名的时候, 如果直接使用变量名调用, 那么会优先访问局部变量, 如果没有才会访问成员变量.

                            这时如果希望直接访问成员变量, 那么就要使用"this.变量名"的形式

                            this就代表调用当前方法的对象

         b.调用构造函数

                            在构造函数的第一条语句, 使用"this(参数列表)"可以调用当前类的其他构造函数.

                            注意不要形成递归.

[java]  view plain copy

1. <span style="font-size:14px;">class Person {  
2.         private String name;  
3.         private int age;  
4.         Person()  
5.         {}  
6.         Person(String name){  
7.             this.name = name;  
8.         }  
9.         Person(String name, int age) //构造方法的重载  
10.         {  
11.             this(name);//调用其他构造函数  
12.             this.age = age;  
13.         }  
14.     }  
15. </span>  

13.代码块

         1.什么是代码块

                   在Java程序中可以使用{}来定义一段代码, 这就是代码块

                   {}中可以定义变量, 在代码块里定义的变量, 在代码块执行结束后就销毁

                   {}中也可以执行功能代码,{}定义在不同的位置, 执行代码的时机也不同

         2.局部代码块(方法中的)

                   可以在方法中使用{}定义一段代码

                   方法执行的时候, 这段代码也会执行

                   代码块执行结束后, 其中定义的变量都会被销毁

                   通常在临时使用某个变量, 或者临时使用某个对象的时候使用

         3.成员代码块(类中的)

                   可以在类中使用{}定义一段代码

                   在创建对象的时候, 这段代码会执行(类似构造函数)

    4.成员代码块和成员变量赋值的顺序问题

                   顺序是由代码的定义位置而决定的

                   首先会执行定义成员变量, 并且初始化为默认值

                   然后成员代码块和成员变量赋值的语句哪个在上面就先执行哪个

[java]  view plain copy

1. <span style="font-size:14px;">class A {  
2.         int x = 1;  
3.         {  
4.             x = 2;  
5.             System.out.print(x);  
6.         }  
7.         A()  
8.         {  
9.             x = 3;  
10.             System.out.print(x);  
11.         }  
12.     }  
13.     class Test {  
14.         public static void mian(String[] args) {  
15.             A a = new A();//打印结果为 23  
16.         }  
17.     }  
18. </span>  

14.封装，多态

         1.什么是封装

                   封装就是把一类事物的特征和行为定义在一个类中

                   使用这个类创建对象之后, 方法即可访问自己的数据

         2.封装的健壮性(安全性)

                   通常我们在定义类的时候, 成员变量都是私有的(private),不允许其他类直接访问.

                   为了能让其他类访问到成员变量, 我们应该提供公有的(public)get和set方法.

         3.set方法格式

                   publicvoid set变量名(变量类型变量名) {}

         4.get方法格式

                   public变量类型 get变量名() {}

[java]  view plain copy

1. <span style="font-size:14px;">class Person {  
2.         private String name;  
3.         public String getName() {  
4.             return name;  
5.         }  
6.         public void setName(String name) {  
7.             this.name = name;  
8.         }  
9.     }  
10. </span>  

15.static关键字

         1.什么是static关键字

                   static代表静态的, 它可以用来修饰类的成员(变量, 方法, 代码块, 内部类).

                   被static修饰的成员, 都和类加载有关.

         2.类在什么时候加载

                   Java程序中第一次使用某个类的时候, 虚拟机就会从classpath指向的路径中加载该类.

[java]  view plain copy

1. <span style="font-size:14px;">class Demo {  
2.             public static void main(String[] args) {  
3.                 Person p; //这个不算加载类  
4.                 new Person();//这个才是加载类  
5.             }  
6.         }  
7.         class Person {  
8.             static {  
9.                 System.out.println("dddfd");  
10.             }  
11.         }  
12. </span>  

3.静态变量

                   在类中定义的成员变量, 大多数情况下是没有static修饰的, 这种成员变量叫实例变量(创建对象之后才可以使用).

                   如果在成员变量上加上static修饰, 那么这个变量在类加载之后就会初始化(不用创建对象就能用).

                   静态的成员变量被当前类的所有实例共享(只有1个).

                   静态的成员变量可以使用"类名.变量名"直接访问(无需使用对象访问).        

                   如果在定义一个类的时候, 希望当前类的所有对象共享一个变量, 那么这个变量就应该使用static修饰.

         4.静态方法

                   a.普通方法:

                            在类定义的普通方法, 是需要创建对象之后才能调用的.

                   b.静态方法的特点:

                            如果我们在方法前面加上了static,这个方法就是静态方法, 类加载后直接可以使用(不用创建对象).

                            静态方法可以使用"类名.方法名"形式访问

                            静态方法中不能访问非静态成员

                   c.什么时候使用:

                            如果有一个方法不需要访问外面其他非静态成员, 那么就可以定义为静态方法(更方便, 别人使用时不用创建对象). 

         5.静态代码块

                   a.普通代码块:

                            在类中定义的普通成员代码块是在创建对象时执行.

                   b.静态代码块的特点

                            如果我们在代码块前面加了static,这个代码块将在类加载的时候就会执行.

                            静态代码块中不能访问非静态成员.

                   c.什么时候使用:

                            如果希望在类加载的时候做一些事情, 那么就可以放在静态代码块中

[java]  view plain copy

1. <span style="font-size:14px;">class Demo12_Exercise {  
2.     public static void main(String[] args) {      
3.         new A();    // 145253  
4.         new A();    // 253  
5.     }  
6. }  
7.   
8. class A {  
9.     static {  
10.         System.out.println(1);  
11.     }  
12.     static B b1 = new B();  
13.     {  
14.         System.out.println(2);  
15.     }  
16.     B b2 = new B();  
17.     A() {  
18.         System.out.println(3);  
19.     }  
20. }  
21. class B {  
22.     static {  
23.         System.out.println(4);  
24.     }  
25.     B() {  
26.         System.out.println(5);  
27.     }  
28. }  
29. </span>  

上述代码执行的顺序为：

         1.因为主函数中有语句newA();所以先加载A类；

         2.随着A类的加载，执行A中的静态成员

         3.执行System.out.println(1);

         4.执行B b1 = newB();这时加载B类，并创建B类的一个对象

         5.随着B类加载，执行B类中的静态成员

         6.执行System.out.println(4);

         7.执行B的构造函数B()，执行System.out.println(5);

         8.执行构造代码块System.out.println(2);

         9.A中静态部分和构造代码块执行完后，执行B b2 = new B();

         10.由于B中静态部分已经执行完，所以只执行B的构造函数System.out.println(5);

         11.执行A的构造函数，System.out.println(3);

         12.执行主函数中的newA()，直接跳过静态部分执行构造代码块，B b2 = new B();和A的  构造函数

         13.执行System.out.println(2);

         14.执行System.out.println(5);

         15.System.out.println(3);

16.文档的制作

         文档的制作

         /**

         这是。。用于实现。。功能

         @author...

         @versionV1.1

         @paramarr 参数

         @return返回值

         */

         要把类声称帮助文档这个类必须是public修饰

         生成文档的命令行：javadoc-d 路径 类

 

         一个类中默认会有一个空参数的构造函数

         这个默认的构造函数的权限和所属类一致

----------------------android培训、java培训、期待与您交流！ ----------------------