7封装_构造函数

7封装_构造函数

导语：

想到在写

2. 介绍匿名对象。1，简化书写，2，使用场景
3. 对象调用的封装提高复用性，匿名对象作为实参传递
4. 基本数据类型参数传递和引用数据类型参数传递
5. 封装的表现和好处，以及私有的使用
6. 构造函数的定义，调用，作用，默认构造函数的体系，构造函数细节。和一般函数的区别
7. 构造函数间的调用，this(),this到底代表哪个对象
8. this的另一个用法，区分成员变量和局部变量同名的情况，以及this关键字的应用
9. 静态关键字static的特点。以及应用。两个问题。需要大家自己找答案解决
   

1. 介绍匿名对象。1，简化书写，2，使用场景

class Car
    {
        //描述属性。颜色，轮胎数。
        String color;
        int number;
    
        //描述行为。
        void run()
        {
            System.out.println(color+":"+number);
        }
    }
    
    class CarDemo
    {
        //定义主函数。为了让程序运行起来。
        public static void main(String[] args)
        {
            /*
            //创建Car.class类的对象。
            Car c = new Car();//类类型变量一定指向对象。
            //调用对象的成员。
            c.color = "red";
            c.number = 4;
            c.run();
            */
    
    //        Car c = new Car();
    //        c.run();
            //简化成这样的写法。所以匿名对象就是为了简化书写。
    //        new Car().run();//这个对象有名字吗？没有，是的。这就是传说中的匿名对象。
    
            /*
            记住：凡是简化的，通常都有局限。
            匿名对象有局限吗?
            */
            new Car().color = "red";//执行完对象就变成了垃圾。
            new Car().number = 4;
            new Car().run();
    
            /*
            那匿名对象有什么用呢？为了简化书写。
            使用场景：当对象对方法进行调用时，而且只调用一次时，可以简化成匿名对象来书写。
             Car c = new Car();c.run(); ---> new Car().run();
    
    
            Car c = new Car();
            c.color = "blue";
            c.run();
            c.run();
            c.run();
            是不可以简化成一下书写的。因为对象不同。
            new Car().color = "blue";
            new Car().run();
            new Car().run();
            new Car().run();
            记住：当对象需要调用多次成员时，不可以简化成匿名对象调用。
            */
    
    
        }
    } 

2. 对象调用的封装提高复用性，匿名对象作为实参传递

class Car
    {
        //描述属性。颜色，轮胎数。
        String color;
        int number;
    
        //描述行为。
        void run()
        {
            System.out.println(color+":"+number);
        }
    }
    
    
    class  CarDemo2
    {
        public static void main(String[] args) 
        {
            /*
            Car c = new Car();
            c.color = "red";
            c.number = 4;
            c.run();
    
            Car c1 = new Car();
            c1.color = "red";
            c1.number = 4;
            c1.run();
            */
    
            //以上代码的复用性有点差。只有对象不同，而调用的成员和赋值都相同。
            //可以进行抽取。定义一个功能。将重复代码封装。
    
            /*
            封装功能后，在使用，就简单了。
            */
            Car c = new Car();
            Car c1 = new Car();
            show(new Car());//简化成 show(new Car());//把匿名对象作为实际参数进行传递。
    
        }
        //功能结果是什么呢？没有具体值。所以是void。
        //功能的未知部分是什么呢？对象不明确。可以将其定义成参数。
        public static void show(Car cc)
        {
            cc.color = "red";
            cc.number = 4;
            cc.run();
        }
    } 

3. 基本数据类型参数传递和引用数据类型参数传递

//课上练习：不要编译运行，求图，求真相！
    class Demo
    {
        public static void main(String[] args)
        {
            int x = 4;
            show(x);
            System.out.println("x="+x);
        }
        public static void/*int*/ show(int x)
        {
            x = 5;
            //return x;
        }
    }
    
    class Demo 
    {
        int x ;
        public static void main(String[] args) 
        {
    
            Demo d = new Demo();
            d.x = 5;
            show(d);//show(new Demo());
            System.out.println("x="+d.x);
        }
        public static void show(Demo d)
        {
            d.x = 6;
        }
    } 

4. 封装的表现和好处，以及私有的使用

 /*
    封装：
    表现：
    1，函数就是一个最基本封装体。
    2，类其实也是一个封装体。
    
    从以上两点得出结论：
    好处：
    1，提高了代码的复用性。
    2，隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。
    3，提高了安全性。
    它也是面向对象思想的特征之一。
    共有三个特征：封装，继承，多态。
    
    
    举例：机箱。隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式。
    
    */
    
    //描述人。Person
    //属性：年龄。
    //行为：说话：说出自己的年龄。
    
    
    
    
    
    /*
    总结：
    类中不需要对外提供的内容都私有化，包括属性和行为。
    
    selectSort(int[] arr)
    {
        swap(
    }
    
    bubbleSort(int[] arr)
    {
        swap(
    }
    
    private swap(int[] arr,int a,int  b)
    {
    
    }
    
    重点：以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。
    
    */
    
    class Person
    {
        //属性：
        private int age;//age就是被修饰为了private私有。也就是被隐藏了。这就是封装的一种体现。
        //行为：
        void speak()
        {
            System.out.println("age="+age);
        }
    
        /*
        年龄已被私有，错误的值无法赋值，可是正确的值也赋值不了，不行。
        咋办，按照之前所学习的封装的原理，隐藏后，还需要提供访问方式。
        通过方法的方式，让其他程序访问到，就可以了。更重要的是可以在方法中加入逻辑判断。
    
        记住：对变量的访问操作有两个动作：赋值(设置 set)，取值(获取 get)
        所以，对私有的变量访问的方式就是 set变量  get变量--> setAge  getAge
        */
        //定义对age赋值的方法。
        void setAge(int a)
        {
            //加入逻辑判断。
            if(a>0 && a<130)
                age = a;
            else
    //            System.out.println("对不起，您的年龄数值 "+a+" 是非法的。");
    //            throw new RuntimeException("对不起，您的年龄数值 "+a+" 是非法的。");//异常！一旦出现，程序结束。需要修正代码。
        }
    
        //定义一个获取age值的方法。
        int getAge()
        {
            return age;
        }
    
    }
    
    class PersonDemo
    {
        public static void main(String[] args)
        {
            //测试Person.class。
            //创建对象。
            Person p = new Person();
    
            /*
            赋值-20是可以的，因为age属性是int类型，但是确不符合现实生活中的事物。
            怎么解决这个问题呢？
            不让它访问就哦了。怎么在代码上实现呢？需要使用一个Java中的关键字也是一个修饰符 private(私有，权限修饰符)
            记住：私有仅仅是封装的体现形式而已。
    
            */
    //        p.age = -20;//age不能在person类以外的程序中直接访问了。
    
            //演示对age设置和获取方法的体现。
            p.setAge(-20);
            int a = p.getAge();
            System.out.println("a="+a);
    //        p.speak();
        }
    } 

5. 构造函数的定义，调用，作用，默认构造函数的体系，构造函数细节。和一般函数的区别

/*
    需求：为了描述事物更准确，发现事物对应的很多对象一创建时，
    就有了，一些初始化的数据。在类中该如何完成的。
    
    通过Java中的另一个小技术完成：就是构造函数。对象本身就是构造出来，
    构造时，需要做一些动作这些应该定义在函数内。
    
    构造函数（Constructor）有什么用？可以对对象创建进行初始化。
    
    构造函数怎么在代码中体现呢？
    1，没有返回值类型。因为构造对象，创建完就结束，需要结果。void也不要写，因为要有区别与一般函数。
    2，构造函数名称和类名一致。
    3，没有具体的返回值。
    接下来，按照以上三点，在Person类中定义一个构造函数。
    对象一创建就具备了姓名。
    
    
    发现了问题？
    没有学习构造函数时，对象也创建出来了。那么该对象是否有被构造呢？或者说是否有调用构造函数呢？
    
    是的。必须调用！
    那么类中那个构造函数是什么呢？
    
    class Person
    {
        //Person(){}//默认的空参数构造函数。
    }
    
    main()
    {
        Person p = new Person();//这就已经调用了Person类中的空参数的构造函数。
                                //类中有定义该构造函数吗？有的。只要定义一个类，
                                //该类中默认就有一个空参数的构造函数，是编译器编译时添加到class文件中。
                                //注意：如果在类中自定义了构造函数，那么默认的空参数构造函数编译器就不添加了。
                                //原理：没有定义对象的初始化过程，编译器会添加一个默认的初始化过程。
                                //      如果定义了指定的对象初始化过程，默认的就不添加了。
    }
    
    
    
    
    构造函数的细节：
    1，一个类中可以有多个构造函数，它们的存在是以重载的形式体现的。
    2，构造函数中也是有return语句的，用于结束初始化动作的。
    3，构造函数是否能被private修饰呢？能，作用：其他程序无法创建该类的对象。
    class Person
    {
        private Person(){}
    }
    
    
    main()
    {
        Person p = new Person();//创建对象无法初始化。
    }
    
    构造函数和一般函数的区别？
    1，写法不一样。不重要。
    2，运行上有差别，对象一创建就会调用对应的构造函数。
        一般方法是对象创建后，才会调用所需的一般函数。
    问：有了构造函数初始化姓名，那么还需要setName方法吗？
    需要，因为对象创建后，如果需要对数据进行修改，可以通过set完成。
    3，构造函数在对象创建时，仅调用一次(初始化动作只做一次，而且先执行)。一般方法可以被对象调用多次。
    
    class Person
    {
        //Person(){}
        void Person(){}//这是一般函数。但不要这些书写，因为一般函数名称有规范。
    }
    
    main()
    {
        Person p = new Person();
    }
    
    
    */
    
    class Person
    {
        //属性：姓名，年龄。
        private String name;
        private int age;
        //一初始化，既没有姓名，又没有年龄。
        Person()
        {
    
        }
    //    Person(int a)
    //    {
    //        if(a<0)
    //            return;
    //        age = a;
    //    }
    
    
        //定义构造函数，对象一创建就具备姓名。
        Person(String n)
        {
            //将接收到的值赋值给对象的name
            name = n;
        }
    
        //一初始化既有姓名，又有年龄。
        Person(String n,int a)
        {
            name = n;
            age = a;
    
        }
    
        //行为。
        public void speak()
        {
            System.out.println("name="+name+",age="+age);
        }
    }
    
    
    class PersonDemo2 
    {
        public static void main(String[] args) 
        {
    
            Person p1 = new Person();
    
    //        Person p = new Person("lisi");//对象创建时，必须会调用对应的构造函数，因为对象需要初始化。
    
    //        Person p2 = new Person("wangwu",23);
    
        }
    } 

6. 构造函数间的调用，this("/>,this到底代表哪个对象

/*
   当构造函数之间进行互相调用时，该如何解决呢？
   
   构造函数是对象初始化时调用的。
   给哪个对象初始化呢？通过this关键字来记录住对象的地址。并通过this来明确被初始化的对象。
   
   在构造函数中调用其他构造函数的格式： this(实参列表);就会调用对应的构造函数。
   
   小节：
   this到底代表什么呢？★★★★★
   this就代表对象，代表哪个对象呢？哪个对象调用了this所在函数，this就代表哪个对象。
   
   
   */
   class Person
   {
       private String name;
       private int age;
       Person()
       {
   
       }
       //初始化姓名。
       private Person(String n)
       {
   
           name = n;
       }
       //初始化姓名和年龄。既然有初始化姓名的动作。直接调用就可以了。
       Person(String n,int a)
       {
   
           this(n);//调用一个字符串参数的构造函数。注意：调用其他构造函数的语句，
                   //必须定义在构造函数的第一行。原因：初始化动作要先执行。
   //        name = n;
           age = a;
       }
   
   
   }
   
   class PersonDemo3 
   {
       public static void main(String[] args) 
       {
           Person p = new Person("lisi",20);
           Person p1 = new Person("lisi1",21);
       }
   } 

7. this的另一个用法，区分成员变量和局部变量同名的情况，以及this关键字的应用

 /*
    this关键字的另一个作用：
    可以用this标识哪个变量是成员变量。这个标识可以省略不写。
    但是，当局部变量和成员变量同名时，必须用this.来标识成员变量。
    
    
    */
    class Person
    {
        private String name;
        private int age;
    
        Person(String name,int age)
        {
            this.name = name;
            this.age = age;
        }
        public void speak()
        {
            String name = "haha";
            System.out.println("name="+this.name+",age="+this.age);
        }
        public void method()
        {
            this.speak();//this可以省略。
        }
    
        //课上练习,定义功能，判断两个人是否是同龄人。
        //1,明确结果，boolean 2,明确未知内容，1个，Person类型。
        public boolean equalsAge(Person pp)
        {
            /*
            if(pp.age == this.age)//当函数中使用到了调用该函数的对象时，用this表示这个对象。
                return true;
            return false;
            */
    //        return (pp.age == this.age)?true:false;
            return pp.age == this.age;
        }
    }
    
    class PersonDemo4 
    {
        public static void main(String[] args) 
        {
            Person p = new Person("lisi",20);
            p.speak();
            Person p1 = new Person("xiaoming",24);
            p1.speak();
        }
    } 

8. 静态关键字static的特点。以及应用。两个问题。需要大家自己找答案解决

 /*
    静态关键字的特点：
    1，静态成员优先于对象存在，被对象共享。
    2，静态成员可以直接类名调用，多一个调用方式。
    3，静态成员所属于类，所以它是随着类的加载而加载，随着类的消失而消失。
    
    
    
    */
    
    
    class Person
    {
        //属性：国籍。如果这个程序只限中国人使用，国籍都是中国。
        //如果每一个对象中都存储一份中国，不是不行，只是内存浪费。能不能实现这个中国数据的对象共享呢？
        //可以的，通过Java中的一个关键字就可以完成。static。这是一个成员修饰符。
        static String country = "中国";//显示初始化。这个country的值就不在对象存储了。被对象共享了。
        String name;
        public static void show()
        {
            System.out.println(Person.country);
    //        System.out.println(name);
        }
    }
    
    /*
    
    静态变量和成员变量的区别？
    
    什么时候定义静态变量。什么时候函数需要用静态修饰？
    
    
    
    
    */
    
    
    class PersonDemo5 
    {
        public static void main(String[] args) 
        {
    //        Person p1 = new Person();        
    //        Person p2 = new Person();
    //        System.out.println(p1.country);
            System.out.println(Person.country);//共享数据在对象之前就已经存在了。可以有另一种调用方式。可以直接被类名调用。
                                                // 静态的成员所属的是类。
    
            Person.show();
    
        }
    }