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

首先我们定义一个Person类的对象，里面放入人的相关信息

　　我们再从外部用对象调用person类里面其中的一个年龄，进行访问输出

　　这时候我们就发现了一个问题，要是我们从外部传入一个负数进来呢，这是不合逻辑的

其次我们就在person类中把age私有化

　　但是私有化却只能在内类中访问，外部无法访问

　　我们就要在person类中建立一个访问方法

　　一般来说，一个事物通常会对应两个方法，一个set，一个get

但是这样还是可以从外部调用访问方法传入一个负数进来

其实我们这样做是为了可以在方法类中进行逻辑判断语句，提高代码健壮性。

//封装原则


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();
    }
}

从以上分析中，这就运用了Java面向对象中的一个关键字private

private：私有权限修饰符，用于修饰类中的成员（成员变量，成员函数）

　　　　私有仅仅是封的一种表现形式

一个人都会有一些自带的属性，比如：姓名和年龄

　　每建立一个人的时候就要进行初始化，把这个人的特性展现出来

这时候就要运用构造函数的特点

由于，构造函数只运行一次，如果要多次调用，还是要建立一般方法

我们也就在分析事物中，该事物具备一些特性或行为，就把这些内容定义在构造函数中

再来说一个构造代码块

　　作用：给对象进行初始化。

　　对象一建立就运行，而且由于构造函数执行。

　　构造代码块和构造函数的区别：　　

　　　　构造代码块是给所有对象进行统一初始化

　　　　构造函数是给对应的对象初始化

　　构造代码块中定义的是不同对象共性的初始化内容。

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);
    }
}

为了区分局部变量与成员变量，我们可以用this关键字，来区分同名的情况

　　对于this来说，哪个对象在调用了this所在的函数，this就代表哪个对象this应用

this的应用：

　　用于构造函数间的调用

　　只能定义构造函数第一行，因为初始化要先执行。　　

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)
    }
}

static静态关键字

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);
    }
}

// 什么时候定义静态函数呢？

// 当功能内部没有访问到费静态数据费静态数据（对象的特有数据）

// 那么该功能就可以定义成静态的

class Person
{
    String name;
    public void show() //public static void show() 
    {
        System.out.println(name+"haha");  //像这样访问到特有数据时，就不能加static
    }
}

class StaticDemo2
{
    public static void main(String[] args) {

        Person.show();  //像一个没有访问到特有数据name时，就把方法定义成静态
    }
}

静态的利与弊

　　利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象都存储一份，可以直接被类名调用

　　弊：生命周期过长；访问出现局限性（静态虽好，只能访问静态）

静态代码块：

　　随着类的加载而执行，只执行一次，优先于主函数，用于给类初始化

class StaticCode
{
    static{
        System.out.println("b");
    }
    public static void show()
    {
        System.out.println("show run");
    }
}

class StaticDemo3
{
    static
    {
        // System.out.println("b");  //第一个执行，因为静态代码块
    }
    public static void main(String[] args) {
        // new StaticCode();   //调用staticcode，输出a
        // new StaticCode();  //因为是静态代码块，只执行一次，所以不再执行a
        // System.out.println("over");  //最后执行，over

        StaticCode s=null;  //这样staticcode是不会执行的，因为传递的空值，没有任何意义，只要运用类里面的内容，才有效
        s=new StaticCode();  //这样也算，因为方法会默认一个一个构造函数
    }
    static
    {
        // System.out.println("c");  //还是静态代码块，继续执行
    }
}

//执行结果：b c a over

再就是对于类的一个面试题目

//一个面试题目

class StaticCode
{
    int num=9;  //2、如果在中添加一个num
    StaticCode()
    {
        System.out.println("b");
    }

    static
    {
        System.out.println("a");  //3、想要访问这个num  是访问不到的，因为num是非静态成员，就是访问不了
    }

    {
        System.out.println("c"+num);  //4、在构造代码块中则可以运行，因为使用对象初始化
    }

    StaticCode(int x)
    {
        System.out.println("d");
    }

    public static void show()
    {
        System.out.println("show run");
    }
}

class StaticDemo4
{
    public static void main(String[] args) {
        new StaticCode(4);  
        //1、执行结果：a c d  因为优先访问静态代码块，再访问构造代码块，最后构造函数带参数的方法
    }
}

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

猜你喜欢