《java笔记 day07》

 //匿名对象_1
 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是类类型的变量。类类型的变量一定
                             //指向对象。（引用型的变量也可以不指向
                             //变量，例如Car c = null）
         //调用对象的成员。
         //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.run();
         c.run();
         c.run();
         是不可以简化成以下书写的。因为对象不同。
         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(c);//简化成show(new Car())
         //show(c1);
         show(new Car());

     }

     //功能的结果是什么呢？没有具体值，所以是void.
     //功能的未知参数是什么呢？对象不明确，可以将其定义成函数。
     public static void show(Car cc)//Car cc = c
     {
         cc.color = "red";
         cc.number = 4;
         cc.run();
     }
 }

 //基本数据和引用数据参数传递过程。
 class Demo
 {
     public static void main(String[] args)
     {
         int x = 4;
         show(x);
         System.out.println("x="+x);//打印结果为：x=4
     }
     public static void/*int*/ show(int x)
     {
         x = 5;
         //return x;
     }
 }

 class Demo2
 {
     int x;
     public static void main(String[] agrs)
     {
         Demo2 d = new Demo2();
         d.x = 5;
         show(d);//show(new Demo());
         System.out.println("x="+d.x);//打印结果为x=6
     }
     public static void show(Demo d)
     {
         d.x = 6;
     }
 }

 //封装。

 /*
 封装：
 表现：
 1，函数就是一个封装最基本的封装体。
 2,类其实也是一个封装体。

 从以上两点得出结论：
 1，提高了代码的复用性。
 2，隐藏了实现的细节，对外提供访问方式。
 3，提高了安全性。
 它也是面向对象思想的特征之一。
 共有三个特征：封装，继承，多态。

 举例：机箱。隐藏了板卡设备的细节，对外提供了插口以及开关等
       访问内部细节的方式。
 */
 //描述人。Person
 //属性：说话：说出自己的年龄。

 /*
 总结：
 类中不需要对外提供的内容私有化，包括属性和行为。 

 selectSort(int[] arr)
 {
     swap(){}
 }

 bubbleSort(int[] arr)
 {
     swap(){}
 }

 重点：以后再描述事物，属性都私有化，并提供setXXX,getXXX方法对其进行访问。
 */
 class Person
 {
     //属性。
     private int age;    //age就被修饰为了private私有，
                         //也就是被隐藏了，这就是封装的
                         //一种体现。

     //行为。
     void speak()
     {
         System.out.println("age="+age);
     }

     /*
     年龄已被私有，错误的值无法赋值，可是正确的值也赋值不了。不行。
     咋办，安照之前所学习的封装的原理，隐藏后，还需要提供访问方式。
     通过方法的方式，让其他程序访问到就可以了，更重要的是可以在方法
     中加入逻辑判断。

     记住：对变量的访问操作有两个动作；赋值（设置），取值（获取）.
     所以，对私有的变量访问的方式就是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();
     }
 }

 /*
 什么叫做封装：
 隐藏了实现细节，提供对外访问的方式，这才叫封装，而私有仅仅是
 封装的一种体现。
 */

 //面向对象---构造函数。
 /*
 需求：为了描述事物更准确，发现事物对应的很多对象一创建时，
       就有了一些基本的属性等内容。一些初始化的数据，在类中
       该如何完成。

 通过Java中的另一个小技术完成：就是构造函数，对象本身就是构造出来的。
 构造时，需要做一些动作，这些应该定义在函数内。

 构造函数有什么用？可以在对象创建时对对象进行初始化。
 1，没有返回值类型。因为构造对象，创建完成就结束，不需要结果。void也不要写
    因为要区别于一般函数。
 2，构造函数的名字和类名一样。（构造函数就是给类在创建对象是而提供的）
 3，没有具体的返回值。
 接下来，安照以上三点，在Person类中定义一个构造函数。
 Person类的对象一创建就具备了姓名。

 发现了问题.
 没有学习构造函数时，对象也被创建出来了，那么该对象是否有被构造呢？后者
 说是否有调用构造函数呢？

 是的，必须调用！
 那么类中那个构造函数是什么呢？

 class Person
 {
     //Person(){}//默认的空参数的构造函数。
 }

 main()
 {
     Person p = new Person();    //这个已经调用了Person类中的空参数的构造
                                 //函数，类中有定义构造函数吗？有的，只要
                                 //定义了一个类，该类中就有一个空参数的构造
                                 //函数，是编译器编译时自动加上的。

                                 //注意：如果在类中自定义了构造函数，那么默认
                                 //的空参数的构造函数就不添加了。防止冲突。

                                 //原理：没有定义对象的初始化过程，编译器会添加一个默认的
                                 //初始化过程，如果定义了指定的初始化过程，默认的就不添加了。
 }

 什么时候需要些构造函数呢？
 如果对象一初始化就具备了一些内容，这需要写构造函数，在对象被创建的时候，用这个构造函数来初始化这个对象。
 如果对象初始化时不具备内容，这不需要写构造函数。用setXXX来指定。

 构造函数细节：
 1，一个类可以有多个构造函数，它们的存在是以重载的形式体现的。
 2，构造函数中也是有return语句的，用于结束初始化动作的。
 3,构造函数是否能被private修饰呢？ 能。作用就是，其他程序无法创建该类的对象。
   但是在本类里面还是可以创建对象的。
 class Person
 {
     private person(){}//私有化构造函数。
 }
 main()
 {
     Person p = new Person();    //创建对象无法初始化
 }

 构造函数和一般函数的区别：
 1，写法不一样。
 2，运行上有差别，对象一创建就会调用对应的构造函数。
     一般方法是对象创建后，才会调用所需的一般函数。
 问：有了构造函数初始化姓名，那么还需要setName方法吗？需要，因为对象创建之后，
     如果需要对数据进行修改，可以通过set完成。
 3，构造函数在对象创建时，仅调用一次（因为初始化动作只做一次，而且先执行）。而一般方法可以被调用多次。
 class Person
 {
     //这个类里面还有一个默认的空参数构造函数。
     void Person(){}//这不是构造函数，这是一般函数。
 }
 main()
 {
     Person p = new Person();
 }
 */
 class Person
 {
     //属性：姓名，年龄
     private String name;
     private int age;

     //一初始化，既没有姓名，又没有年龄。
     Person()
     {

     }

     //return语句用于结束初始化动作演示：
 //    Person(int a)
 //    {
 //        if(a<0)
 //            return;    //return语句用于提前结束初始化动作。
 //        age = a;
 //    }

     //定义构造函数。
     Person(String n)
     {
         //将接受到的值赋值给对象的name。
         this.name = n;
     }

     //一初始化，既有姓名，又有年龄。
     Person(String n,int a)
     {
         name = n;
         age = a;
     }

     //行为：
     public void speak()
     {
         System.out.println("name="+this.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",18);
         p.speak();
         p1.speak();
         p2.speak();
     }
 }

 //构造函数——之间的调用。
 /*
 当构造函数之间进行互相调用时，该如何解决呢？

 构造函数是对象初始化时调用的。
 给哪个对象初始化呢？通过this关键字来明确被初始化的对象。

 在构造函数中调用其他构造函数的格式：this(实参列表);就会调用对应的构造函数。

 小结：
 this到底代表什么呢？
 this就代表对象，代表哪个对象呢？哪个对象调用了this所在的函数，this就代表了哪个对象。
 */
 class Person
 {
     private String name;
     private int age;
     Person()
     {

     }
     //初始化姓名。
     private Person(String n)
     {
         name = n;
 //        cry();    //构造函数调用一般方法，
     }
     //初始化姓名和年龄,既然第二个构造函数已经做完了构造姓名的动作，这个构造函数就没有必要做了。直接调用就好了。
     Person(String n,int a)
     {
         this(n);    //thsi代表当前对象，//这是在调用一个字符串参数的构造函数。
                     //注意：调用其他构造函数的语句，必须定义在构造函数的第一行，
                     //原因是，初始化动作必须要先执行。
     //    name = n;
         age = a;
     }

     //一般方法，
     void cry()
     {

     }
 }

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

     }
 }

 //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();//这个方法可以省略，因为方法如果同名的话还可以用参数列表来区分。
     }

     //定义一个功能，判断两个人是否是同龄人。
     //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();
         p1.method();
         */
         Person p = new Person("lisi",20);
         boolean l = p.equalsAge(new Person("xiaoming",21));
         System.out.println(l);
     }
 }