黑马程序员---面向对象1

----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

1.面向对象概念

    a.面向对象的特点
        封装性：
            封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。
        继承性：
            继承性主要描述的是类与类之间的关系，通过继承，可以在无须重新编写原有类的情况下，对原有类的功能进行扩展。
        多态性：
            多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，他们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。
2.类与对象
    a.类的定义：类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，
        成员方法用于描述对象的行为，可简称为方法。
        Demo：     

    class Person{
        int age;
        void speak(){
            System.out.println("大家好，我今年"+age+"岁");
        }
    }

        注：Person是类名，age是成员变量，speak()是成员方法    
    b.对象的创建和使用：
        格式：类名 对象名称 = new 类名();    如：Person p = new Person();
    c.类中成员变量的初始化值
        数据类型                默认初始化值
        byte short int                 0
        long                               0L
        float                               0.0F
        double                          0.0D
        char                              空字符，即'\u0000'
        boolean                        false
        引用数据类型              null
3.构造方法
    a.条件：
        方法名与类名相同
        在方法名前没有返回值类型的声明
        在方法中不能使用return语句返回一个值
        Demo:   

    class Person{
        public Person(){
            System.out.println("无参构造函数被调用了");
        }                
    }    
    public class Demo{
        public static void main(String[] args){
            Person p = new Person();    //实例化Person对象
        }
    }

         注：在实例化Person对象时会自动调用类的构造方法，"new Person"语句除了会实例化Person对象，还会调用构造方法Person().
    b.构造方法重载
        与普通方法一样，构造方法也可以重载，在一个类中可以定义多个都早方法，只要每个构造方法的参数类型或参数个数不同即可。
    Demo： 

     class Person{
            String name;
            int age;
            public Person(String name, int age){
                this.name = name;
                this.age = age;
            }
            public Person(String name){
                this.name = name;
            }
            public void speak(){
                System.out.println("大家好，我叫"+name+",我今年"+age+"岁！");
            }
        }
        public class Demo{
            public static void main(String[] args){
                Person p1 = new Person("张三");    
                Person p2 = new Person("李四",18);    
                p1.speak();
                p2.speak();
            }
        }

         注：在java中每个类都至少有一个构造方法，如果一个类中没有定义构造方法，系统会自动为这个类创建一个默认的无参构造方法。如果这个类定义了一个有参构造方法，那么系统就不会再为这个类创建无参构造方法了。
4.this关键字
    a.this关键字作用：
        用于在方法中访问对象的其他成员
    b.this关键字的三种常见用法
        通过this关键字可以明确地去访问一个类的成员变量，解决与局部变量名称冲突的问题。
            Demo：   

    class Person{
        int age;
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }    
    }

        通过this关键字调用成员方法。
            Demo:   

    class Person{
        public void run(){
            System.out.println("I am running.");
        }
        public void speak(){
            this.run();
        }
    }

         构造方法是在实例化对象时被java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用"this([参数1,参数2...])"的形式来调用其他的构造方法。
            Demo:      

    public class Demo {
        public static void main(String[] args) {
            Person p = new Person("hanxuhui");
        }
    }

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

        注：在使用this调用类的构造方法是，应注意以下几点
            1)只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用
            2)在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。
            3)不能再一个类的两个构造方法中使用this互相调用。
5.垃圾回收
    在java中，当一个对象成为垃圾后仍会占用内存空间，针对这种情况，java引入了垃圾回收机制，java虚拟机会自动回收垃圾对象所占用的内存空间。
    当一个对象在内存中被释放时，它的finalize()方法会被自动调用。
        Demo：  

   public class Demo {
        public static void main(String[] args) {
            Person p1 = new Person();
            Person p2 = new Person();
            p1 = null;    //将变量置为null，使对象成为垃圾
            p2 = null;
            for(int i=0; i<1000000; i++){
                //为了延长程序运行时间
            }
        }
    }
    class Person{
        public void finalize() throws Throwable {
            System.out.println("对象将被作为垃圾回收...");
        }    
    }

     注：java虚拟机的垃圾回收操作是在后台完成的，程序结束后，垃圾回收的操作也将终止。
6.static关键字
    a.静态变量
        在一个java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，可以使用"类名.变量名"的形式来访问。
        Demo:       

    public class Demo {
        public static void main(String[] args) {
            Student s1 = new Student();
            Student s2 = new Student();
            Student.schoolName = "cqjtu";
            System.out.println("My school name is "+s1.schoolName);
            System.out.println("My school name is "+s2.schoolName);
        }
    }
    class Student{
        static String schoolName;
    }

        注：static关键字只能用于修饰成员变量，不能用于修饰局部变量，否则编译会报错。    
    b.静态方法
        类中的方法使用static关键字修饰，该方法即为静态方法。同静态变量一样，静态方法可以使用"类名.方法名"的方式来访问，也可以通过类的实例对象来访问。
        Demo：

    public class Demo {
        public static void main(String[] args) {
            Student.sayHello();
        }
    }
    class Student{
        public static void sayHello(){
            System.out.println("Hello");
    }

        注：在一个静态方法中只能访问static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。
    c.静态代码块
        在java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化。
        Demo:     

   public class Demo {
        static{
            System.out.println("测试类的静态代码块被执行了。。。");
        }
        public static void main(String[] args) {
            Student s1 = new Student();
            Student s2 = new Student();
        }
    }
    class Student{
        static String name;
        static{
            name = "hanxuhui";
            System.out.println("Studnet类中的静态代码块被执行了。。。");
        }
    }

7.单例模式
    a.概念：单例模式是java中的一种设计模式，它是指在设计一个类时，需要保证在整个程序运行期间针对该类只存在一个实例对象。
    b.实现条件：
        1)类的构造方法使用private修饰，声明为私有，这样就不能在类的外部使用new关键字来创建实例对象了。
        2)使用静态变量INSTANCE引用一个null的该类实例变量，由于变量应该禁止外界直接访问，因此使用private修饰，声明为私有成员。
        3)为了让类的外部能够获得类的实例对象，需要定义一个静态方法getInstance(),用于返回该类实例INSTANCE。由于方法是静态的，外界可以使用"类名.方法名"的方式来访问。
    Demo:  

  public class Single {
        //声明一个Single类引用，初始化为null
        private static Single INSTANCE = null;
        //私有化Single类构造方法，不允许外部new实例对象
        private Single() {}
        //返回实例对象（第一次调用时INSTANCE为null,使用new创建实例对象，以后再调用就返回同一个对象实例）
        public static Single getInstance(){
            if(INSTANCE == null){
                return INSTANCE = new Single();
            }
            return INSTANCE;        
        }
    }

8.内部类

    在java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。
    a.成员内部类
        在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称为成员内部类。在成员内部类中可以访问外部类的所有成员。
        Demo:

    public class Outer {    
        public String name = "Outer";    
        class Inner{
            void showName(){
                System.out.println(name);
            }
        }    
        public static void main(String[] args) {
            Inner inner = new Outer().new Inner();
            inner.showName();
        }
    }

        注：内部类可以在外部类中被使用，并能访问外部类的成员。如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象，格式为：
            外部类名.内部类名 变量名 = new外部类名().new 内部类名();
            如果内部类声明为私有，外界将无法访问。
    b.静态内部类
        使用static关键字修饰一个成员内部类，该内部类被称为静态内部类，他可以在不创建外部类对象的情况下被实例化。
        创建静态内部类对象的语法格式为：    外部类名.内部类名 变量名 = new 外部类名.内部类名();
        Demo:  

    public class Demo {
        public static void main(String[] args) {
            Outer.Inner inner = new Outer.Inner();
            inner.showName();
        }
    }
    class Outer {    
        public static String name = "Outer";    
        static class Inner{
            void showName(){
                System.out.println(name);
            }
        }        
    }

        注：在静态内部类中只能访问外部类的静态成员。
            在静态内部类中可以定义静态成员，而在非静态内部类中不允许定义静态的成员
    c.方法内部类
        方法内部类是指在成员方法中定义的类，他只能在当前方法中被使用。
        Demo: 

    public class Demo {
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.print();
        }
    }
    class Outer {    
        public static String name = "Outer";    
        public void print(){
            class Inner{
                void showName(){
                    System.out.println(name);
                }
            }
            Inner inner = new Inner();
            inner.showName();
        }        
    }

        注：方法内部类也能访问内部类的成员

----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------