【学习笔记】面向对象基础1

一、类与对象

1、类：封装对象的属性和行为的载体，即同一类型对象（事物）的抽象描述，定义了这一类对象共同的静态和动态属性。

       鸟类： ①行为：飞行、捕食、吃东西……

            ②属性：翅膀、爪子、嘴……

2、对象：计算机语言对一个具体事物的描述，静态属性（成员变量）和动态属性（方法）的封装体。

             1）静态部分：即属性/成员变量，任何对象都会具备其自身属性。  eg:一个人具备的属性有：高矮、胖瘦、性别年龄等。

             2）动态部分：即行为/方法，具有属性的人会执行的动作。       eg:一个人具有的行为：微笑、说话、行走等。

3、类与对象的关系：类是对象的抽象（一组具有共同特征的对象的模板），对象是类的具体实例。           

        类实质上就是封装对象属性和行为的载体，对象是类抽象出来的一个实例。

 二、类

1、类的定义：使用关键字class定义类。

           1）组成：成员变量和成员方法

                 成员变量：类的属性

                 成员方法：类的行为

            2）结构：

                public class 类名{

               //定义属性部分

                 属性1的类型  属性1；

                 属性2的类型  属性2；

                   …………

                 属性n的类型  属性n;

               //定义方法部分

               方法1;

               方法2;

                   ……

               }

           3）java文件中:

                ① 可以有一个或多个类（class）

                ② 可以有零个或者一个用public修饰的类

                ③ public修饰的class名称必须和类文件名称相同

                ④ 无public修饰的class不能跨包访问

                ⑤ 一个类生成一个字节码文件(.class文件)   

 

2、数据成员（成员变量）

         1）定义形式：  权限修饰符  类型  成员名；

                  eg：  private String name;

                        public char firstName = 'L';

         2）成员变量可以在定义时自动初始化。

            成员变量的类型可以设置为Java中合法的数据类型。实际上，成员变量就是普通的变量，可以为它设置初始值，也可以不设置初始值。若不设置初始值，则会有默认值。

                     

         3）封装性：权限修饰符private修饰的成员变量，只能在本类中访问。

PS:权限修饰符

        ①主要类型：public private protected  default(无访问修饰符)

                     

         ②当声明类时不使用public、protected、private修饰符设置类的权限，则这个类预设为包存取范围，即只有一个包中的类可以调用这个类的成员变量

            class AnyClass{                public void doString(){                        …//方法体                    }                }

            在上述代码中，由于类的修饰符为默认修饰符，即只有一个包内的其他类和子类可以对该类进行访问。而AnyClass类中的doString()方法却又被设置为public 访问权限，即使这样，doString()方法的访问权限依然与AnyClass类的访问权限相同，因为Java语言规定，类的访问权限会约束类成员的权限设定，所以上述代码等同于下列代码：

  

           

 class AnyClass{                void doString(){                     …//方法体                    }                }

         4）局部变量：局部变量在方法被执行时创建，在方法执行结束时被销毁，在使用时必须进行赋值操作或被初始化，否则会出现编译错误 

                    public String getName(){        //定义一个getName()方法                           int id = 0;              //局部变量，去掉初始值，则编译错误                           setName("Java");         //调用类中其他方法                           return id + this.name；  //设置方法返回值                     }

                    ①作用范围：即变量的作用域，从该局部变量的声明开始到该变量的结束为止。(即最近的两个大括号之间)

                      Ⅰ.在不同嵌套区域可以定义相同名称和类型的局部变量

                            

public void doString(String name){                                    int id = 0;                                    for(int i=0;i<10;i++){                                        System.out.println(name+String.valueof(i));}                                    for(int i=0;i<10;i++){                                       System.out.println(i);}                                }

                      Ⅱ.在嵌套区域中不可以定义相同名称的类型和局部变量

                         

  public void doString(String name){                                int id = 0;                                for(int i=0;i<10;i++){                                    System.out.println(name+String.valueof(i));}                                for(int i = 0;i<3;i++){                                    System.out.prinln(i);                                    int id = 7;}                                }

3、方法

     1）定义形式：    修饰符  返回值类型 方法名（[参数类型 参数名]）{

                             方法体语句;

                          }  

                       方法的定义不能嵌套

     2)return :表示方法的返回。

                格式：return 返回值;    --------------  return 0；

                public int swap(int a,in b){                    //此为有参方法                    int max = 0;                    if(a>b)   max = a;                    else      max = b;                    return max;                        }   

      3)void ：表示方法无返回值 ，可以用return 结束。

               

 public void hello(){                              //此为无参方法                    System.out.println("Hello World!");                    return;                            }

      4） 

public class Student{                    private int no = 1;                    private char firstNamec;                    private int scoreJava;                    public void intoduce(){                        System.out.println("My name is:"+firstName);                    }                    public int getNo(){                        return no;                    }                    public void setNo(int theNo){                        no = theNo;                    }                    pulic char getFirstName(){                        return firstName;                    }                    public void setFirstName(char fn){                            name = fn;                    }……                }    

三、对象

1、 对象的创建

    1）创建对象的一般格式：类名  对象名 = new 类名（[参数]）;

                           类名    对象名  = new 类名（[参数]）;

                           类名    引用变量  = new 对象名（）；

                           对象名（引用变量（栈））——>对象（类名（堆））;   

       eg:Student liuxiang =  new Student();    Test test = new Test();  

           Test test = new Test("a");   

           test对象被创建出来的时候，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，可以在构造方法中初始化成员变量。当创建对象时，自动调用构造方法，也就是说在Java中初始化与创建是被捆绑在一起的。

           每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的生命周期。当一个对象的生命周期结束时，对象就变成垃圾，由Java虚拟机自带的垃圾回收机制处理，不能再被使用。

    2）创建对象的步骤：

         ①创建对象：为对象创建内存，并初始化为0或null                

         ②执行显示初始化

         ③执行构造方法

         ④对象的引用赋值给引用变量（将句柄指向对象）

    3）创建对象的等价形式及内存调用情况

        ①类名 对象名; 

             ·声明引用类型变量，不分配内存

         ②对象名  = new 类名（[参数]）; 

             ·为对象分配内存，创建对象

             ·为引用变量分配内存，指向对象（实际为指针） 

    4）内存空间的分配小结

         ① 同一类的每个对象的成员变量占用不同的存储空间

         ② 引用类型变量存放在栈内存中  

         ③ 对象是通过new产生的，位于堆内存，类的每个成员变量在不用的对象中可能有不同的值（静态变量除外）。

         ④ 方法仅一份，存放在方法区，执行时分配内存。同一类的每个对象共享该类的代码。

              

2、对象的引用

    1）访问引用实例的属性与方法

        ① 对象使用“.”进行以下操作：

           ·访问对象的属性格式： 对象名.属性;----多个引用比那里的永明属性在内存中有多个拷贝

                                    stu.no;

       ★    · 调用类的方法 ：对象名.方法名(); ----多个引用变量的同名方法在内存只有一个。

                                    stu.getNo();   

                               

        ② 引用变量赋值

                

          1）先成员变量，后方法

          2）public 为修饰符，public修饰的class名必须与类文件名相同

          3）尽量在一个java文件中一个class，即类。注意是否为内部类

       

    2） 成员变量与局部变量

            当局部变量与成员变量同名时会屏蔽成员变量。

              

    3）方法调用

        ① 方法的分类

            ·主调方法：调用其他方法的方法

              · 被调方法：被其他方法调用的方法

         ② 方法调用的条件

            参数个数相等，顺序一致，类型相同或兼容。

         ③ 方法的形参与实参

            · 形参和实参占用不同的存储单元，形参只有被调用是才临时被分配到存储空间，调用结束后释放。

              · 实参可以是常量、变量或者表达式，但必须有确定的值。

              · 方法调用时实参向形参进行单向传递，即只由实参传给形参，而不能由形参传回给实参

         

    4）方法的调用可以嵌套

               

    5）值传递：参数的数据类型是基本数据类型。实参->形参单向传递.int heigh = 5;

             Arthur.age = 23;

               System.out.println(Arthur.age);

         

    6）引用传递：

参数的数据类型是引用类型

               Boy tom = new Boy(); 

                //引用传递，参数的数据类型是引用类型

                tom.setGF(Arthur);     //面向对象基础1_类与对象

           

   

3、权限修饰符   

4、对象的比较   

     Student myStudent1 = new Student()；

      Student myStudent2 = new Student();

      myStudent = myStudent2;

      //比较两个变量存储的内容是否相同，比较地址

    

   ·equals方法

     myStudent1.equals(myStudent2);

    //默认等同：myStudent1 == myStudent2;

      当两个引用指向同意个对象时为true，按位比较 

5、对象的销毁

   1） Student myStudent = null;

    ·当引用变量为null是们不能调用成员方法和成员变量

    ·当对象不再被引用变量引用的时候，会被垃圾回收（释放出new分配的内存。）

    ·辣鸡回收期只能回收那些有new操作符创建的对象

   2）对象销毁机制

        ·JVM（虚拟机）的垃圾回收器找机会自动回收垃圾对象

        ·finalize()方法

            ·说明：在类中定义，是Object类方法，被声明为protected

            ·工作原理：垃圾回收器准备释放对象占用的存储空间时，首先调用finalize方法，在下一次垃圾回收发生时，再真正的回收对象占用的内存。

            ·作用：在垃圾回收时做一些重要的清理工作（尽量不使用该方法）

        ·System.gc();立即执行

一、类与对象

1、类：封装对象的属性和行为的载体，即同一类型对象（事物）的抽象描述，定义了这一类对象共同的静态和动态属性。

        eg:

           

        鸟类： ①行为：飞行、捕食、吃东西……

               ②属性：翅膀、爪子、嘴……

2、对象：计算机语言对一个具体事物的描述，静态属性（成员变量）和动态属性（方法）的封装体。

             1）静态部分：即属性/成员变量，任何对象都会具备其自身属性。  eg:一个人具备的属性有：高矮、胖瘦、性别年龄等。

             2）动态部分：即行为/方法，具有属性的人会执行的动作。       eg:一个人具有的行为：微笑、说话、行走等。

3、类与对象的关系：类是对象的抽象（一组具有共同特征的对象的模板），对象是类的具体实例。  

             

     类实质上就是封装对象属性和行为的载体，对象是类抽象出来的一个实例。

 二、类

1、类的定义：使用关键字class定义类。

           1）组成：成员变量和成员方法

                 成员变量：类的属性

                 成员方法：类的行为

            2）结构：

                public class 类名{

                //定义属性部分

                属性1的类型  属性1；

                属性2的类型  属性2；

                    …………

                属性n的类型  属性n;

                //定义方法部分

                方法1;

                方法2;

                    ……

                }

           3）java文件中:

                ① 可以有一个或多个类（class）

                ② 可以有零个或者一个用public修饰的类

                ③ public修饰的class名称必须和类文件名称相同

                ④ 无public修饰的class不能跨包访问

                ⑤ 一个类生成一个字节码文件(.class文件)   

 

2、数据成员（成员变量）

         1）定义形式：  权限修饰符  类型  成员名；

                  eg：  private String name;

                        public char firstName = 'L';

         2）成员变量可以在定义时自动初始化。

            成员变量的类型可以设置为Java中合法的数据类型。实际上，成员变量就是普通的变量，可以为它设置初始值，也可以不设置初始值。若不设置初始值，则会有默认值。

                     

         3）封装性：权限修饰符private修饰的成员变量，只能在本类中访问。

PS:权限修饰符

        ①主要类型：public private protected  default(无访问修饰符)

                     

         ②当声明类时不使用public、protected、private修饰符设置类的权限，则这个类预设为包存取范围，即只有一个包中的类可以调用这个类的成员变量

            package com.lzw;

            class AnyClass{

                public void doString(){

                        …//方法体

                    }

                }

            在上述代码中，由于类的修饰符为默认修饰符，即只有一个包内的其他类和子类可以对该类进行访问。而AnyClass类中的doString()方法却又被设置为public 访问权限，即使这样，doString()方法的访问权限依然与AnyClass类的访问权限相同，因为Java语言规定，类的访问权限会约束类成员的权限设定，所以上述代码等同于下列代码：

            package com.lzw;

            class AnyClass{

                void doString(){

                     …//方法体

                    }

                }

         4）局部变量：局部变量在方法被执行时创建，在方法执行结束时被销毁，在使用时必须进行赋值操作或被初始化，否则会出现编译错误 

                    public String getName(){        //定义一个getName()方法

                           int id = 0;              //局部变量，去掉初始值，则编译错误

                           setName("Java");         //调用类中其他方法

                           return id + this.name；  //设置方法返回值

                     }

                    ①作用范围：即变量的作用域，从该局部变量的声明开始到该变量的结束为止。(即最近的两个大括号之间)

                      Ⅰ.在不同嵌套区域可以定义相同名称和类型的局部变量

                            public void doString(String name){

                                    int id = 0;

                                    for(int i=0;i<10;i++){

                                        System.out.println(name+String.valueof(i));}

                                    for(int i=0;i<10;i++){

                                       System.out.println(i);}

                                }

                      Ⅱ.在嵌套区域中不可以定义相同名称的类型和局部变量

                            public void doString(String name){

                                int id = 0;

                                for(int i=0;i<10;i++){

                                    System.out.println(name+String.valueof(i));}

                                for(int i = 0;i<3;i++){

                                    System.out.prinln(i);

                                    int id = 7;}

                                }

3、方法

     1）定义形式：    修饰符  返回值类型 方法名（[参数类型 参数名]）{

                             方法体语句;

                          }  

                       方法的定义不能嵌套

     2)return :表示方法的返回。

                格式：return 返回值;    --------------  return 0；

                eg：public int swap(int a,in b){                    //此为有参方法

                    int max = 0;

                    if(a>b)   max = a;

                    else      max = b;

                    return max;    

                    }   

      3)void ：表示方法无返回值 ，可以用return 结束。

                eg:public void hello(){                              //此为无参方法

                    System.out.println("Hello World!");

                    return;        

                    }

      4）例：  public class Student{

                    private int no = 1;

                    private char firstNamec;

                    private int scoreJava;

                    public void intoduce(){

                        System.out.println("My name is:"+firstName);

                    }

                    public int getNo(){

                        return no;

                    }

                    public void setNo(int theNo){

                        no = theNo;

                    }

                    pulic char getFirstName(){

                        return firstName;

                    }

                    public void setFirstName(char fn){

                            name = fn;

                    }……

                }    

三、对象

1、 对象的创建

    1）创建对象的一般格式：类名  对象名 = new 类名（[参数]）;

                           类名    对象名  = new 类名（[参数]）;

                           类名    引用变量  = new 对象名（）；

                           对象名（引用变量（栈））——>对象（类名（堆））;   

       eg:Student liuxiang =  new Student();    Test test = new Test();  

           Test test = new Test("a");   

           test对象被创建出来的时候，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，可以在构造方法中初始化成员变量。当创建对象时，自动调用构造方法，也就是说在Java中初始化与创建是被捆绑在一起的。

           每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的生命周期。当一个对象的生命周期结束时，对象就变成垃圾，由Java虚拟机自带的垃圾回收机制处理，不能再被使用。

    2）创建对象的步骤：

         ①创建对象：为对象创建内存，并初始化为0或null                

         ②执行显示初始化

         ③执行构造方法

         ④对象的引用赋值给引用变量（将句柄指向对象）

    3）创建对象的等价形式及内存调用情况

        ①类名 对象名; 

             ·声明引用类型变量，不分配内存

         ②对象名  = new 类名（[参数]）; 

             ·为对象分配内存，创建对象

             ·为引用变量分配内存，指向对象（实际为指针） 

    4）内存空间的分配小结

         ① 同一类的每个对象的成员变量占用不同的存储空间

         ② 引用类型变量存放在栈内存中  

         ③ 对象是通过new产生的，位于堆内存，类的每个成员变量在不用的对象中可能有不同的值（静态变量除外）。

         ④ 方法仅一份，存放在方法区，执行时分配内存。同一类的每个对象共享该类的代码。

              

2、对象的引用

    1）访问引用实例的属性与方法

        ① 对象使用“.”进行以下操作：

           ·访问对象的属性格式： 对象名.属性;----多个引用比那里的永明属性在内存中有多个拷贝

                                    stu.no;

       ★    · 调用类的方法 ：对象名.方法名(); ----多个引用变量的同名方法在内存只有一个。

                                    stu.getNo();   

                               

        ② 引用变量赋值

                

          1）先成员变量，后方法

          2）public 为修饰符，public修饰的class名必须与类文件名相同

          3）尽量在一个java文件中一个class，即类。注意是否为内部类

       

    2） 成员变量与局部变量

            当局部变量与成员变量同名时会屏蔽成员变量。

              

    3）方法调用

        ① 方法的分类

            ·主调方法：调用其他方法的方法

              · 被调方法：被其他方法调用的方法

         ② 方法调用的条件

            参数个数相等，顺序一致，类型相同或兼容。

         ③ 方法的形参与实参

            · 形参和实参占用不同的存储单元，形参只有被调用是才临时被分配到存储空间，调用结束后释放。

              · 实参可以是常量、变量或者表达式，但必须有确定的值。

              · 方法调用时实参向形参进行单向传递，即只由实参传给形参，而不能由形参传回给实参

         

    4）方法的调用可以嵌套

               

    5）值传递：参数的数据类型是基本数据类型。实参->形参单向传递.int heigh = 5;

             Arthur.age = 23;

               System.out.println(Arthur.age);

         

    6）引用传递：

参数的数据类型是引用类型

               Boy tom = new Boy(); 

                //引用传递，参数的数据类型是引用类型

                tom.setGF(Arthur);     //面向对象基础1_类与对象

           

   

3、权限修饰符   

      修饰类的成员变量与方法时的访问范围

    

4、对象的比较   

     Student myStudent1 = new Student()；

      Student myStudent2 = new Student();

      myStudent = myStudent2;

      //比较两个变量存储的内容是否相同，比较地址

    

   ·equals方法

     myStudent1.equals(myStudent2);

    //默认等同：myStudent1 == myStudent2;

      当两个引用指向同意个对象时为true，按位比较 

5、对象的销毁

   1） Student myStudent = null;

    ·当引用变量为null是们不能调用成员方法和成员变量

    ·当对象不再被引用变量引用的时候，会被垃圾回收（释放出new分配的内存。）

    ·辣鸡回收期只能回收那些有new操作符创建的对象

   2）对象销毁机制

        ·JVM（虚拟机）的垃圾回收器找机会自动回收垃圾对象

        ·finalize()方法

            ·说明：在类中定义，是Object类方法，被声明为protected

            ·工作原理：垃圾回收器准备释放对象占用的存储空间时，首先调用finalize方法，在下一次垃圾回收发生时，再真正的回收对象占用的内存。

            ·作用：在垃圾回收时做一些重要的清理工作（尽量不使用该方法）

        ·System.gc();立即执行