代码封装/匿名对象/关键字（this ，static）/工具类main方法/

1.代码封装

1.此处引入关键字private
a. 当类的成员变量使用private 修饰符修饰，那么就不可以直接访问到该成员变量.
b. 当使用private 修饰的成员变量或者成员方法，仅能在本类中使用
c. private 对于main 方法的修饰，也是可以产生作用的.

public class DemoPrivate{


    public static void main(String[] args){
        Person person =new Person();
        person.name = "diffo";
        person.setAge(20);
        person.eat();//error
        person.action();
    }

}

class Person{
    String name;
    private int age;

    void setAge(int ageParm){
        if(ageParm>0 && ageParm<150){
            age = ageParm;
        }
    }

    void eat(){
       System.out.println("eat");   
    }

    void action(){
        eat();
        speak();
    }

    void speak(){
        System.out.println("speak!: "+name+" . "+age);
    }
}

2.代码的封装是对隐藏对象的属性和细节，仅对外提供公共方法访问
3.javaBean/POJO类.

//java bean
class Person{
    private String name;
    private int age;

    void setName(String nameParm){
        name = nameParm;
    }

    String getName(){
        return name;
    }

    void setAge(int ageParm){
        age = ageParm;
    }

    int getAge(){
        return age;
    }

    void speak(){
        System.out.println(name+" . "+age);
    }

    public static void main(String[] args){
        Person person = new Person();
        person.setName("diffo");
        person.setAge(30);
        person.speak();
    }
}

class DemoBean{

    static void main(String[] args){
        Person person = new Person();
        person.setName("diffo");
        person.setAge(30);
        person.speak();
    }

}

它的所有成员变量都使用private 进行修饰，并且对外提供可访问的设置值和获取值的set,get方法。

2.匿名对象

顾名思义，既没有名字的对象，同样可以给变量赋值，也可以调用方法，其意义在于可以节省代码

public class Student{

    static String className;

    public static void main(String[] args){
        Student student = new Student();
        student.className = "java";     
        System.out.println(new Student().className);
        System.out.println(new Student().className);
    }

}

3.关键字

1.this

1.含义:
代表了当前对象的引用.
可以理解为，当前谁来调用，那么方法中的this 就代表谁。

对于成员变量可以区分出来的场景，this 可加也可以不加，实际效果相同。
但是对于实现javaBean/POJO 来说，我们建议都加上在setXXX,getXXX方法中.

this:
可以加在成员变量的前面来指定对应的引用，也可以加在成员方法的前面。

2.static

a.随着类加载而加载
静态方法区中来保存静态成员变量
b.优先于对象创建
c.被类的所有对象共享
静态的成员变量会保存在该class的静态方法区中，所以每个对象看到的都是同一份.
d.可以通过类名来访问也可以通过对象名来访问。
效果是一样的。
e.推荐通过类名来访问
f.静态的成员，一般称为类相关的成员。
f.static 修饰符既可以修饰成员变量，也可以修饰成员方法。 且修饰之后，就可以通过类名来直接访问到。
g.this变量在静态方法中不可以使用
h.静态方法中只能访问静态成员变量和静态方法。
非静态方法既可以访问静态成员和方法也可以访问非静态成员和方法。
非静态虽然可以访问静态的方法，但是不建议这样做。

public class DemoStatic{
    public static void main(String[] args){
        Person person = new Person();

        Person.action();
        //Person.speak();

        /*
        person.name="ryan";
        System.out.println(new Person().name);
        System.out.println(Person.name);
        */
        method();
    }

    static void method(){
        System.out.println("method");
    }
}

class Person{
    static String name = "diffo";
    static int age = 20;

    void speak(){
        System.out.println("speak:"+age);
    }

    static void action(){
        speak();
    }
}

4.main方法

void: 不需要返回值.
方法名: main
参数列表: 执行的时候，可以传递参数.

5.工具类

全部都是静态的方法。所以可以通过 类名.functionName() 方式来访问。
一般的话，都会对默认构造方法进行私有化处理，来防止别人使用时习惯性的创建对象来调用方法。
课堂练习

public class ClassTestFinal{

    public static void main(String[] args){
        Square square = new Square();
        square.setLength(2);

        System.out.println(SquareUtil.getCircumLength(square));
        System.out.println(SquareUtil.getArea(square));
    }

}

//pojo类
class Square{
    private int length;

    void setLength(int length){
        this.length = length;
    }

    int getLength(){
        return this.length;
    }
}

//正方形工具类
class SquareUtil{

    private SquareUtil(){

    }

    static  int getCircumLength(Square square){
        return 4*square.getLength();
    }

    static   int getArea(Square square){
        return square.getLength()*square.getLength();
    }
}

//工具类: 都是把其中的方法定义为static
public class MathUtil{

    //加法
    static int sum(int num1,int num2){
        return num1+num2;
    }

    //减法，乘法 

    private MathUtil(){

    }

    public static void main(String[] args){
        System.out.println(MathUtil.sum(2,3));

        new User().getResult();

    }
}

class User{

    void getResult(){
        System.out.println(MathUtil.sum(2,3));
    }

}