面向对象（二）

1、final关键字

      final关键字可用于修饰类、变量和方法，它有“这是无法改变的”或者“最终”的含义，因此被final修饰的类、变量和方法具有以下特性：

          A：final修饰的类不能被继承。

          B：final修饰的方法不能被子类重写。

          C：final修饰的变量（成员变量和局部变量）是常量，只能赋值一次。

 

2、构造方法

     定义：在一个类中定义的方法如果同时满足一下三个条件，该方法称为构造方法，具体如下：

             A：方法名与类名相同。

             B：在方法名前面没有返回值类型的声明。

             C ：在方法中不能使用return语句返回一个值。

 

     1）、例子：（无参构造方法）

 

             class Person {
               // 下面是类的构造方法
               public Person() {
                System.out.println("无参的构造方法被调用了...");
                       }
             }

            public class Text {
               public static void main(String[] args) {
               Person p = new Person();  // 实例化 Person 对象
                        }
               }       

 

     2）例子：（有参构造方法，通过有参构造方法实现对属性的赋值）     

             

             class Person {
                   int age;
                  // 定义有参的构造方法
                public Person(int a) {
                           age = a;                       // 为age属性赋值
                 }
                public void speak() {
                        System.out.println("I am " + age + " years old.!");
                 }
             }

            public class Text{
                    public static void main(String[] args) {
                         Person p = new Person(20); // 实例化 Person 对象
                          p.speak();
                   }
            }
    
       

        3）、构造方法的重载

                 与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。

           class Person {
                  String name;
                  int age;
                 // 定义两个参数的构造方法
                 public Person(String con_name, int con_age) {
                        name = con_name; // 为name属性赋值
                        age = con_age;   // 为age属性赋值
                 }
               // 定义一个参数的构造方法
               public Person(String con_name) {
                         name = con_name;  // 为name属性赋值
                }

             public void speak() {
                  // 打印name和age的值
                 System.out.println("大家好，我叫" + name + ",我今年" + age + "岁!");
             }
       }

              public class  Text{
                 public static void main(String[] args) {
                // 分别创建两个对象 p1 和 p2
                Person p1 = new Person("陈杰");
                Person p2 = new Person("李芳", 18);
               // 通过对象p1 和 p2 调用speak()方法
               p1.speak();
               p2.speak();
               }
           }

             注意：如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法，这个默认的构造方法没有参数。只要类中定义了有参构造方法，系统将不再自动生成无参的构造方法，最好再定义一个无参构造方法，避免调用无参的构造方法报错。构造方法使用public来修饰。

          

3、this关键字

       1）、通过this关键字可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题。

            class  Personal{

                 int age;

                public Personal（int age）{

                     this.age = age;

                }

               public int getAge（）{

                    return  this.age;

               }

          }

       

           2）、通过this关键字调用成员方法：

                 class Personal{

                        public void open{

                        }

                        public void speak（）{

                           this.open（）;

                       }

                 }

             

           3）、构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this（[参数1，参数2....]）”的形式来调用其他的构造方法。

           class Person {
                public Person() {
                     System.out.println("无参的构造方法被调用了...");
                }
               public Person(String name) {
                      this();                  // 调用无参的构造方法
                      System.out.println("有参的构造方法被调用了...");
                }
            }

 

            public class Text {
                 public static void main(String[] args) {
                      Person p = new Person("rrt"); // 实例化 Person 对象
                 }
             }

        注意 ：在使用this调用类的构造方法时，应注意：

              A：只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。

              B：在构造方法中，使用this调用构造方法的的语句必须位于第一行，且只能出现一次。

              C：不能在一个类的两个构造方法中使用this互相调用。

  

4、static关键字

     1）、静态变量 ：在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享。static关键字只能用于修饰成员变量，不能用于修饰局部变量。通过“类名.变量名”访问

          class Student {
              static String schoolName;  // 定义静态变量schoolName
           }

          public class Text {
               public static void main(String[] args) {
              Student stu1 = new Student();      // 创建学生对象
              Student stu2 = new Student();
              Student.schoolName = "江西科技";  // 为静态变量赋值
              System.out.println("我的学校是" + stu1.schoolName); // 打印第一个学生对象的学校
              System.out.println("我的学校是" + stu2.schoolName); // 打印第二个学生对象的学校
            }
         }
         

     2）、静态方法： 有时候我们希望在不创建对象的情况下就可以调用某个方法，也就是说使该方法不必和对象绑在一起，只需要在类中定义的方法前加上static关键字即可，这种方法称为静态方法。在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

     class Person {
           public static void sayHello() { // 定义静态方法
               System.out.println("hello");
           }
     }

     class Text {
           public static void main(String[] args) {
                Person.sayHello();     // 调用静态方法
          }
      }
 

    3）、静态代码块：在Java类中，使用一对大括号包围起来的若干行代码被称作一个代码块，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此惊呆代码块只执行一次。在程序中，通常是会用静态代码块来对类的成员变量进行初始化。

       class Example14 {   
              // 静态代码块
             static {           
                    System.out.println("测试类的静态代码块执行了");
             }

         public static void main(String[] args) {
               // 下面的代码创建了两个Person对象
               Person p1 = new Person();
               Person p2 = new Person();
             }
         }
     

         class Person {
             static String country;
            // 下面是一个静态代码块
           static {           
              country = "china";
              System.out.println("Person类中的静态代码块执行了");
           }
      }