面向对象---封装(Encapsulation)

//封装原则


class  Person
{
    private int age;  //2、我们就用private隐藏起来,外界对象无法访问，只能在本类中访问
    //3、但是人应该有年龄，就需要在person类中提供对应的访问方式
    public void SetAge(int a)   // 这就是一个访问方法---3
    {
        if(a>0&&a<130){
            age=a;
        }
        else
            System.out.println("error");

    }
    public int GetAge()   // 这就是一个访问方法---3
    {
        return age;  
    }
    //4、一个事物通常会对应两个方法，一个set，一个get
    void speak()
    {
        System.out.println("age="+age);
    }
}

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

        //p.age=-20;   //1、一般来说人的年龄不能负，这就违背了原则，就把年龄隐藏起来
        p.SetAge(-20);  //调用访问方法，访问年龄，虽然这个可以传递负数，但是可以在方法类中进行逻辑判断语句，提高代码健壮性---3
        p.speak();
    }
}

class Person
{
    private String name;
    private int age;
    Person()
    {
        System.out.println("A:name="+name+",age="+age);
        //cry();   //全部放到构造代码块中
    }
    //构造代码块
    {
        System.out.println("person code run");
        cry();
    }
    Person(String n)
    {
        name=n;
        System.out.println("B:name="+name+",age="+age);
        //cry();
    }
    Person(String n,int a)
    {
        name=n;
        age=a;
        System.out.println("A:name="+name+",age="+age);
        //cry();
    }
    public void SetName(String n){
        name=n;
    }
    public String GetName(){
        return name;
    }
    public void cry(){
        System.out.println("cry..............");
    }
}

class PersonDemo2
{
    public static void main(String[] args) {
        Person p1=new Person();  //如果把person类中的person()注释掉，则会报错，因为类中已经定义构造函数，所以不会默认
       // Person p1=new Person();  //想要一个孩子哭两次，就定义一般方法，一个对象多次调用，而这个则是定义了两个孩子，才能哭两次。
                                 //这就是一般方法和构造方法的区别
        Person p2=new Person("lis");
        //System.out.println(p2.GetName());
        //p2.SetName("libusi");
        //System.out.println(p2.GetName());
        Person p3=new Person("wangwu",20);
    }
}

class Person
{
    private String name;
    private int age;

    Person(String name)
    {
        //this.name="haha";
        this.name=name;
    }
    Person(String name,int age)
    {
        // this.name=name;  //对象一调用就执行了，执行的是对象里面的，例如"lisi"
        //对于一般函数来说是Person(name)来调用，但是对于构造函数来说是this(name)
        this(name);  //p(name)  但是这个还会调用一下上面的构造函数，例如“haha”
        this.age=age;
    }
}

class PersonDemo4
{
    public static void main(String[] args) {
        Person p=new Person("lisi",30);
        Person p1=new Person(name)
    }
}

class Person
{
    String name;  //1、这称为成员变量，实例变量--也是对象的变量，对象在，他就在
    static String country="CN";//2、因为多个对象中都会具有这个值，所以把它单独提出来，做一个静态，每个对象中都会存在一份，就是对象所共享
                               //3、静态的成员变量，类变量，随着类的加载而加载
    public void show()
    {
        System.out.println(name+"::"+country);
    }
}

class StaticDemo
{
    public static void main(String[] args) {
        // Person p=new Person();
        // p.name="zhangsan";
        // p.show();
        System.out.println(Person.country);
    }
}