类：是一组相关的"属性"和"行为"的集合；
           对象：是该类事物的具体体现；
类的定义：

                1.使用关键字：class(注意小写)
                2.一个java源文件中：
                        1).如果定义多个类，但只有一个是public的；而且源文件名必须与这个public的类名一致；
                        2).如果定义多个类，可以没有public类；源文件名没有一致性要求；
                        3).main()方法不是必须放在public类中；
                3.类中可以定义什么：
                        1).成员变量：
                                A.可以是基本数据类型，也可以是任何引用数据类型；
                                B.可以显示初始化；
                                        class Student{
                                                String name = "张三" ;
                                                int age = 20;
                                        }
                                C.可以隐式初始化；
                                        整型：0
                                        浮点：0.0
                                        字符：'\u0000'
                                        布尔：false
                                        引用类型：null
                        2).成员方法：
                                A.可以有参数，可以没参数；
                                  可以有返回值，可以没有返回值；
                        
                                B.方法的"形参"可以是任何Java类型(基本数据类型、引用数据类型)
                                C.方法的"返回值"可以是任何Java类型(基本数据类型、引用数据类型)
                                D.一个类中可以定义多个同名的方法，但形参列表不完全相同，叫：方法的重载；
                        3).内部类(后面讲)；
                4.成员变量和局部变量的区别：
                        1).成员变量：
                                A.定义在"类体"中；可以是任何数据类型；
                                B.会被自动初始化；
                                        class Student{
                                                String name;
                                                void show(){
                                                        System.out.println("我叫：" + num);        //打印：我叫：null
                                                }
                                        }
                                C.当实例化对象后，被存储在"堆"中；
                                D.当"对象"不被使用(没有任何引用)，并被垃圾回收器回收时被清理；
                                       
                        2).局部变量：
                                A.定义在某个方法、或其它代码块中；
                                B.必须显示初始化，否则不能访问其值；
                                        class Student{
                                                void show(){
                                                        String name;
                                                        System.out.println("我叫：" + name);        //编译错误。局部变量必须显示初始化才能访问其值；
                                                        name = "张三";        //OK。可以被赋值。
                                                }
                                        }
                                C.当方法或其它代码块被执行时，基本数据类型的"值"和引用数据类型的"引用"都是存储在"栈"中；
                                D.当方法或代码块执行完毕时，会被立即清理；
对象的使用：
                1.创建对象使用new关键字；会在堆中分配内存空间；
                        格式：
                                类名         变量名 = new 类名();
                2.一个类可以创建多个对象；
                3.每个“对象”的“成员变量”在"堆"中都有一份独立的空间；
                  每个“对象”的“成员方法”被存储在“方法区”中，多个对象只有一个“方法空间”；
                4.对象的"引用(地址)"被存储在"栈"中；
方法的形参：
                1.可以是"基本数据类型"：
                        1).调用时，必须传递此类型的“值”；
                        2).调用时，是将值复制一份到方法内部；
                        3).在方法内，使用形参接收此值的副本；
                        4).在方法内，如果更改此值，对原值没有影响；
                                int a = 10;
                                show(a);
                                System.out.println(a);
                                ----------------------------------
                                public void show(int n){//n = 20
                                        n = 20;
                                }
                2.可以是“引用数据类型”：
                        1).调用时，必须传递此类型的“引用”；
                        2).调用时，是将“引用(地址)”复制一份到方法内部；
                        3).在方法内，使用形参接收此“引用”的副本；
                        4).在方法内，如果通过此引用更改堆中的值，对原堆中的值将会产生影响；
匿名对象：
                1.匿名对象：没有名字的对象：new Student();
                2.匿名对象的两种使用情况：
                        1).对象调用方法仅仅一次的时候:new Student().show();
                        2).作为实际参数传递:printStudent(new Student());

封装：
                1.直接对外部暴露成员变量是很不安全的，这时可以将成员变量“私有化”，对外提供公有的
                  get和set方法；
                2.封装的好处：
                        1)隐藏实现细节，提供公共的访问方式
                        2)提高了代码的复用性
                        3)提高安全性。
                3.封装的原则：
                        1)将不需要对外提供的内容都隐藏起来。
                        2)把属性隐藏，提供公共方法对其访问。
private关键字：
                1.是一种“访问修饰符；
                  Java中一共有四种访问修饰符：从宽到窄：public，protected，(默认)，private
                2.用于修饰“成员变量”和“成员方法”；
                3.被private修饰的成员，只能在类的内部被其它成员访问。在类外部无法访问；
this关键字：
                1.每个类都有一个“隐式”的变量：this；
                2.它是在实例化对象时，由虚拟机自动赋值的，会被自动赋值为当前对象的“引用”。
                  所以每个对象内的this变量的值是不同的；
                3.this关键字可以调用本对象的“成员属性”、“成员方法”、“构造方法”；
                4.以下情况必须显示的使用this：
                        1).“局部变量”覆盖“成员变量”时，可以使用this显示的访问被覆盖的“成员变量”；
                            否则访问的是“局部变量”；
                        2).在一个构造方法中调用本类的其它构造方法；this()或this(实参)；

类：是一组相关的"属性"和"行为"的集合；
           对象：是该类事物的具体体现；
类的定义：

                1.使用关键字：class(注意小写)
                2.一个java源文件中：
                        1).如果定义多个类，但只有一个是public的；而且源文件名必须与这个public的类名一致；
                        2).如果定义多个类，可以没有public类；源文件名没有一致性要求；
                        3).main()方法不是必须放在public类中；
                3.类中可以定义什么：
                        1).成员变量：
                                A.可以是基本数据类型，也可以是任何引用数据类型；
                                B.可以显示初始化；
                                        class Student{
                                                String name = "张三" ;
                                                int age = 20;
                                        }
                                C.可以隐式初始化；
                                        整型：0
                                        浮点：0.0
                                        字符：'\u0000'
                                        布尔：false
                                        引用类型：null
                        2).成员方法：
                                A.可以有参数，可以没参数；
                                  可以有返回值，可以没有返回值；
                        
                                B.方法的"形参"可以是任何Java类型(基本数据类型、引用数据类型)
                                C.方法的"返回值"可以是任何Java类型(基本数据类型、引用数据类型)
                                D.一个类中可以定义多个同名的方法，但形参列表不完全相同，叫：方法的重载；
                        3).内部类(后面讲)；
                4.成员变量和局部变量的区别：
                        1).成员变量：
                                A.定义在"类体"中；可以是任何数据类型；
                                B.会被自动初始化；
                                        class Student{
                                                String name;
                                                void show(){
                                                        System.out.println("我叫：" + num);        //打印：我叫：null
                                                }
                                        }
                                C.当实例化对象后，被存储在"堆"中；
                                D.当"对象"不被使用(没有任何引用)，并被垃圾回收器回收时被清理；
                                       
                        2).局部变量：
                                A.定义在某个方法、或其它代码块中；
                                B.必须显示初始化，否则不能访问其值；
                                        class Student{
                                                void show(){
                                                        String name;
                                                        System.out.println("我叫：" + name);        //编译错误。局部变量必须显示初始化才能访问其值；
                                                        name = "张三";        //OK。可以被赋值。
                                                }
                                        }
                                C.当方法或其它代码块被执行时，基本数据类型的"值"和引用数据类型的"引用"都是存储在"栈"中；
                                D.当方法或代码块执行完毕时，会被立即清理；
对象的使用：
                1.创建对象使用new关键字；会在堆中分配内存空间；
                        格式：
                                类名         变量名 = new 类名();
                2.一个类可以创建多个对象；
                3.每个“对象”的“成员变量”在"堆"中都有一份独立的空间；
                  每个“对象”的“成员方法”被存储在“方法区”中，多个对象只有一个“方法空间”；
                4.对象的"引用(地址)"被存储在"栈"中；
方法的形参：
                1.可以是"基本数据类型"：
                        1).调用时，必须传递此类型的“值”；
                        2).调用时，是将值复制一份到方法内部；
                        3).在方法内，使用形参接收此值的副本；
                        4).在方法内，如果更改此值，对原值没有影响；
                                int a = 10;
                                show(a);
                                System.out.println(a);
                                ----------------------------------
                                public void show(int n){//n = 20
                                        n = 20;
                                }
                2.可以是“引用数据类型”：
                        1).调用时，必须传递此类型的“引用”；
                        2).调用时，是将“引用(地址)”复制一份到方法内部；
                        3).在方法内，使用形参接收此“引用”的副本；
                        4).在方法内，如果通过此引用更改堆中的值，对原堆中的值将会产生影响；
匿名对象：
                1.匿名对象：没有名字的对象：new Student();
                2.匿名对象的两种使用情况：
                        1).对象调用方法仅仅一次的时候:new Student().show();
                        2).作为实际参数传递:printStudent(new Student());

封装：
                1.直接对外部暴露成员变量是很不安全的，这时可以将成员变量“私有化”，对外提供公有的
                  get和set方法；
                2.封装的好处：
                        1)隐藏实现细节，提供公共的访问方式
                        2)提高了代码的复用性
                        3)提高安全性。
                3.封装的原则：
                        1)将不需要对外提供的内容都隐藏起来。
                        2)把属性隐藏，提供公共方法对其访问。
private关键字：
                1.是一种“访问修饰符；
                  Java中一共有四种访问修饰符：从宽到窄：public，protected，(默认)，private
                2.用于修饰“成员变量”和“成员方法”；
                3.被private修饰的成员，只能在类的内部被其它成员访问。在类外部无法访问；
this关键字：
                1.每个类都有一个“隐式”的变量：this；
                2.它是在实例化对象时，由虚拟机自动赋值的，会被自动赋值为当前对象的“引用”。
                  所以每个对象内的this变量的值是不同的；
                3.this关键字可以调用本对象的“成员属性”、“成员方法”、“构造方法”；
                4.以下情况必须显示的使用this：
                        1).“局部变量”覆盖“成员变量”时，可以使用this显示的访问被覆盖的“成员变量”；
                            否则访问的是“局部变量”；
                        2).在一个构造方法中调用本类的其它构造方法；this()或this(实参)；