java（2） 面向对象

1.类的封装
    *在定义一个类时，将类中的属性私有化，即使用prviate关键字来修饰，私有属性只能在它所在的类中被访问。为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。
    
    class Student {
        private String name; //将name 属性私有化
        private int age;     //将 age 属性私有化
        
        //下面是公有的getXxx() 和 setXxx()方法。
        public String getName(){
            return name;
        }
        
        public void setName(String stuName){
            name = stuName;
        }
        
        public int getAge(){
            return age;
        }

        public void setAge(int stuAge){
        
            //对传入的参数进行检查
            if(stuAge <= 0 ){
                System.out.println("年龄不合法.......");
            }else{
                age = stuAge;
            }
        
        }
        
        public void introduce(){
            System.out.println("大家好，我叫"+ name + ",我今年"+ age + "岁！");
        }
    }

    public class ExampleTest{
        public static void main(String[] args){
            Student stu = new Student();
            stu.setAge(-30);
            stu.setName("liming");
        }
    }


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

        class Person{
            int age;
            public Person(int age){
                this.age = age;
            }
            
            public int getAge(){
                return this.age;
            }
        }
            
    * 通过 this 关键字调用成员方法
    
        class Person{
            public void openMonth(){
                .....
            }
            
            public void speak(){
                this.openMonth();
            }
        }    
    
    * 构造方法是在实例化对象时被java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用this关键字的形式来调用其他构造方法
      
        class Person{

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

        public class ExampleTest{
            public static void main (String[] args){
                //实例化Person对象
                Person p = new Person("itcast"); 
            }
        }    
    
    * 在使用this调用类的构造方法时，应该注意以下两点
        1.只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用
        2.在构造方法中，使用this调用构造方法的语句必须放在第一行，且只能出现一次。
        
            public Person(){
                String name = "小名";
                this(name);  //由于不在第一行，编译错误
            }    


            
3.static 关键字

    * 静态变量，在一个java类中，可以使用 static 关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，可以使用"类名.变量名"的形式来访问。

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

        public class ExampleTest{
            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);
            }

        }
        
        注意：static关键字只能用于修饰成员变量，不能用于修饰局部变量
    
    
    * 静态方法 ，在一个java类中，方法前有 static 关键字修饰，我们称这种方法为静态方法。不需要创建类即可访问，访问方式"类名.方法名"。
    
        class Person{
            public static void sayHello(){        //定义静态方法
                System.out.println("hello");   
            }
        }    

        class ExampleTest{

            public static void main(String[] args){
                Person.sayHello();
            }
        }    
        注意：在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问。

    * 静态代码块，用 static 关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块之执行一次。



4.单例模式
    * 单例模式是java中的一种设计模式，它是指在设计一个类时，需要保证在整个程序运行期间针对该类只存在一个实例对象。
        
        class Single{
            //自己创建一个对象
            private static Single INSTANCE = new Single();
            private Single(){}                                //私有化的构造方法
            public static Single getInstance(){                  //提供返回对象的静态方法
                return INSTANCE;
            }
        }
        
    * 单例模式具备如下特点
        1.类的构造方法使用private修饰，声明为私有，这样就不能在类的外部使用new关键字来创建对象了
        2.在类的内部创建了一个该类的实例对象，并使用静态变量INSTANCE引用该对象，由于变量应该禁止外界直接访问，因此使用private声明为私有成员
        3.为了让类的外部能够获得类的实例对象，定义了一个静态方法getInstance()，用于返回该类实例INSTANCE.外界可以通过" Single.getInstance() "来获取该实例