java面相对象，类和对象，封装，private和this关键字的作用、静态变量、制作工具类帮助文档、代码块。

一：概念

类是java中最基本的单位；一个java文件可以定义多个类；同一个包下类名不能重复。

类：是一组成员变量和成员方法的集合，可以吧类看作一个抽象的概念。一个java文件中只能有一个类被public修饰只需要记住被public修饰的类规范是要与java文件名一致。

对象：是该类的具体表现，具体到一个个体。

成员变量：用于描述事物的信息。

成员方法：用于描述事物能够做什么。

成员变量与局部变量的区别：
    1、在类中定义的位置不同
        成员变量：类中，但是在方法外
        局部变量：定义在方法内部
    2、在内存中的位置也不同
        成员变量：在堆内存中
        局部变量：在栈内存中
    3、初始化值也不同
        成员变量：系统会给予默认值
        局部变量：没有系统给的默认值，必须在定义的时候赋值，亦或者在方法中使用之前赋值，然后才能使用。
    4、生命周期不同
        成员变量的生命周期：随着对象的创建而创建，随着对象的消失而消失
        局部变量的生命周期：随着方法的调用而创建，随着方法的调用完毕而消失

   注意事项：
        1、局部变量的名字可以和成员变量的名字一样，在方法中使用的时候，采用就近原则
            方法中使用的变量，会现在方法内部查找，如果方法内部没有，去成员变量中查找。
        2、方法与方法之间里面的局部变量，不能互相调用。

二：类的使用

1、定义      类名  对象名称 = new  类名(..);

使用前要先new一个对象，才能在main方法里去调用(对象名称.成员变量或者对象名称.方法名）

2、匿名对象：

                  可以直接用  new 类名().成员变量或方法名去调用，new 类名()称为匿名对象。

                  注意，当调用多次的时候，不适合,每次new的时候都是一个新的匿名对象，会频繁的在堆内存中开辟空间

3、注意事项:

（1）当两个引用指向同一个对象

class Phone3{
    //成员变量
    String brand;
    int price;
    String color;

    //成员方法
    public void call(String s){
        System.out.println("打电话给"+s);
    }

    public void sendMessage(){
        System.out.println("发信息");
    }

    public void listenMusic(){
        System.out.println("听音乐");
    }
}


public class PhoneTest3 {
    public static void main(String[] args) {
        //定义一个手机类
        Phone3 p1 = new Phone3();
        //给手机对象p1成员变量赋值
        p1.brand = "小米";
        p1.price = 1999;
        p1.color = "白色";
        System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
        p1.call("雷军");
        p1.sendMessage();
        p1.listenMusic();

        
        //创建第二个手机对象，将第一个对象名赋值给它
        Phone3 p2 = p1;  //p1中存的是地址，赋值后p2也指向它
        p2.brand = "华为";
        p2.price = 19999;
        p2.color = "蓝色";
        System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);//地址没变，数值改变，p1也会输出以上内容
    }
}

（2）当方法中的参数是基本数据类型和引用数据类型。

class Demo2 {
    public int getSum(int a,int b) {
        a=100;
        b=200;
        return a + b;
    }
}

class Student2{
    String name;
    public void speak(){
        System.out.println("我热爱学习");
    }
}

class StudentTest2{
    /**
     * 如果将来你看到一个方法的形式参数是一个类的类型，说明他是一个引用数据类型
     * 这里其实需要的是该类的对象
     * 调用的时候，把main方法中创建好的对象名传过来，实际上传的就是对象的地址值
     */
    public void function(Student2 s){ //Student2 s = st3 = new Student2();
        s.name = "小王";
        s.speak();
    }
}


public class XingShiCanShuDemo {
    public static void main(String[] args) {
        Demo2 d = new Demo2();
        int a = 10;
        int b = 20;
        System.out.println(d.getSum(a,b));//方法传入的是常量值,或者是该类型的变量
        System.out.println("a:"+a+",b:"+b);//当形式参数是基本数据类型的时候，在方法中对变量做修改，不会影响到外部实际的栈内存中的值。

        //要想调用function(),就必须创建StudentTest2对象
        StudentTest2 st2 = new StudentTest2();

        Student2 st3 = new Student2();
        System.out.println(st3.name);
        st2.function(st3);//这里实际上传的是地址值；
        System.out.println(st3.name);// 当形式参数是引用数据类型的时候，在方法中对变量做修改，会影响到外部实际的堆内存中的值。
    }
}

三：封装

1、概述：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式（提供方法）。

2、优点：隐藏实现细节，提供公共的访问方式 提高了代码的复用性 提高安全性。

3、private关键字：是一个权限修饰符；

                               可以修饰成员(成员变量和成员方法)；

                               被private修饰的成员只在本类中才能访问，相当于在main方法中被隐藏了。

     private最常见的应用：把成员变量用private修饰；提供对应的 获取值方法：getXxx() ；赋值方法：setXxx()

例：标准类1.0  用private修饰变量   getXXX/setXXX ：快捷键alt+insert然后选取方法    show()：用来打印所有变量的值的方法

public class Teacher {
    //定义成员变量
    private String name;
    private int age;

    //提供公共的getXxx()和setXxx()方法
    public void setName(String s) {
        name = s;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge(){
        return age;
    }

    //提供一个方法打印所有的成员变量值
    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age);
    }
}

class TeacherTest{
    public static void main(String[] args){
        //创建一个老师对象
        Teacher t1 = new Teacher();
        //使用成员变量
        //不能直接获取，因为它们都被private修饰了
        //通过公共的方法来获取成员变量
        System.out.println(t1.getName()+"---"+t1.getAge());

        //给成员变量赋值
        t1.setName("刘志城");
        t1.setAge(18);
        System.out.println(t1.getName()+"---"+t1.getAge());
        t1.show();

    }
}

4、this：代表的是调用方法的当前对象

标准类2.0   在setXXX方法中用this.变量代表成员变量；快捷键alt+insert然后选取方法，可以快速建立get和set方法。

class Doctor {
    private String name;//成员变量
    public void setName(String name) {//用name是为了更好的赋值，使用方法更方便。
        this.name = name;//为了区分方法中定义的name和成员变量，this.name代表成员变量。
    }
    public String getName() {
        return name;
    }
    
    public void show() {
        System.out.println("姓名：" + name );
    }
}

public class DoctorDemo {
    public static void main(String[] args) {
        //创建一个医生对象
        Doctor d = new Doctor();
        d.setName("王宇");
        
        d.show();
    }
}

5、构造方法

 （1）定义格式

                               类名（..）{

                              }

（2）作用：new对象调用的是无参构造方法创建对象，之前没有构造方法是因为系统默认自动创建无参构造方法，如果有了构造方法，无参或有参，系统都不会再创建了

  (3)注意：如果在类中创建了一个带参的构造，没有无参构造，new对象是就要使用有参构造放法了，因为系统不会在创建无参构造方法了。

（4）标准类3.0 ：

成员变量：name 、age 他们都是被private修饰
构造方法：无参构造方法，带所有参数的构造方法
成员方法：getXxx()/setXxx(...) 
show()：遍历所有的成员变量的值

class Teacher {
    private String name;
    private int age;

    
    Teacher() {  //无参构造方法

    }

    Teacher(String name, int age) {  //有参构造方法
        this.name = name;
        this.age = age;
    }

    //getXxx()
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    //setXxx(...)
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //show()
    public void show() {
        System.out.println(name + "---" + age);
    }
}

public class TeacherDemo {
    public static void main(String[] args) {
        //使用无参构造方法创建对象，使用setXxx() 对成员变量进行赋值
        Teacher t1 = new Teacher();//若上面没有有参和无参，则默认无参构造。
        t1.setName("小王");
        t1.setAge(18);
        t1.show();

        //使用带参数的构造方法创建对象并给成员变量进行赋值
        Teacher t2 = new Teacher("小杨", 18);
        t2.show();
    }
}

6、static

它可以修饰成员变量和成员方法,修饰后可以叫做静态变量或方法

（1）静态变量特点：

                （1）随着类的加载而加载

                （2）优先于对象存在

                （3）被类的所有对象共享（是否使用静态关键字的条件）

                          例 ：中国人国籍都是中国，static可以修饰成员变量国籍，而国籍则可以被所有对象所共享

                （4）可以通过类名调用：类名.静态成员  或者  对象名.静态成员

（2）注意事项:

在静态方法中是没有this关键字的，不能修饰构造方法。

静态方法只能访问静态的成员变量和静态的成员方法，非静态方法则都可以访问

（3）静态变量和成员变量的区别

所属不同 ：静态变量属于类，所以也称为为类变量                                              成员变量属于对象，所以也称为实例变量(对象变量)

内存中位置不同： 静态变量存储于方法区的静态区                                              成员变量存储于堆内存

内存出现时间不同 ：静态变量随着类的加载而加载，随着类的消失而消失          成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同 ：静态变量可以通过类名调用，也可以通过对象调用                            成员变量只能通过对象名调用

（4）main方法的格式讲解：
    public static void main(String[] args){....}

    public: 公共的，访问权限是最大的，因为main是由JVM调用的，所以权限要足够大
    static: 静态的，不需要创建对象，通过类名直接调用，方便JVM访问
    void: 表示无返回值，因为我们直接说过返回值，是返回给调用者的，而调用main方法是由JVM调用的，返回给他没有意义

四：制作工具类帮助文档

1、制作工具类：ArrayTools.java

/**
 * 这是针对数组相关操作的工具类
 * @author 小虎
 * @version V.1.0
 *
 */
public class ArrayTool {
    /**
     * 这是私有的无参构造方法
     */
    private ArrayTool(){

    }


    /**
     * 这是遍历数组的方法，遍历后的格式是[元素1,元素2,元素3...]
     * @param array 这是调用该方法时需要传入的参数，数据类型是int类型的数组
     */
    public static void printArray(int[] array){
        for(int i=0;i<array.length;i++){
            if(i==array.length-1){
                System.out.print(array[i]+"]");
            }else if(i==0){
                System.out.print("["+array[i]+",");
            }else {
                System.out.print(array[i]+",");
            }
        }
        System.out.println();
    }

    /**
     * 这是数组逆序的方法
     * @param array 这是调用该方法时需要传入的参数，传入的数据类型是int类型的数组
     * @return 返回逆序后的数组
     */
    public static int[] niXu(int[] array){
        for(int start=0,end=array.length-1;start<=end;start++,end--){
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;
        }
        return array;
    }
}

2、找到ArrayTools.java文件，编码改成如下所示：

 3、新建一个文件夹（随便哪里），复制目录，在ArrayTools.java目录下打开cmd；输入javadoc -d 目录 -author -version ArrayTool.java

      文件中就会出现帮助文档，打开index.html，根据上面代码给出的注释，会出来每个方法的作用，能让其他更方便的使用它。

七：代码块

1、概念：

                    在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为

                    局部代码块，构造代码块，静态代码块，同步代码块(多线程在说)。

2、分类：

 （1）局部代码块：在方法中出现，限定变量的生命周期，及早释放，提高内存的利用；

                               在同一个类中的同一个方法中，如果存在多个局部代码块，执行顺序是自上而下的。

（2）构造代码块：（在创建对象的时候调用）
                                定义在类中方法外。当一个类中既存在构造代码块也存在构造方法的时候，无论类中有多少个构造代码块，构造代码块之间会先                                  进行自上而下的顺序执行，然后再执行构造方法。
                                构造代码块 -- >构造方法

（3）静态代码块： 在类中方法外定义，并加上static修饰。静态代码块是优先于其他代码块之前执行，在执行时只执行一次

3、执行顺序 ：     

                         静态代码块 -- 局部代码块 -- 构造代码块 -- 构造方法

public class CodeDemo {

    static{      //静态代码块
        int a = 22;
        System.out.println(22);
    }

    CodeDemo(){      //构造方法
        int y = 300;
        System.out.println(y);
    }

    {             //定义在类中方法外，使用大括号括起来的代码，称之为构造代码块
        int x = 200;
        System.out.println(x);
    }

    static {  //静态代码块
        int a = 11;
        System.out.println(a);
    }

    public static void main(String[] args) {

        {           //局部代码块
            int x = 10;
            System.out.println(x);
        }
        CodeDemo codeDemo = new CodeDemo();

    }
}
//结果为  22  11  10  200  300

class Student2{
    static {
        System.out.println("这是在Student2类中静态代码块");  // 1
    }
    {
        System.out.println("这是在Student2类中的构造代码块"); // 2
    }
    Student2(){
        System.out.println("这是Student2类中的无参构造方法");// 3
    }
}


public class CodeTest {
    static {
        System.out.println("这是在CodeTest类中的静态代码块"); // 4
    }

    public static void main(String[] args) {
        System.out.println("开始执行main方法"); // 5
        {
            System.out.println("这是在CodeTest中的局部代码块"); // 6
        }
        Student2 student2 = new Student2();
    }
}
//结果 4 5 6 1 2 3