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