XObject.java 对象还没写完，希望电脑不会丢失。坏笑，早点见。

/*面向对象强调的是对象,
面向过程强调的是功能行为,打开行为,关闭行为,执行行为,把多个行为封装成对象执行更强大的功能就是面向对象,是把多个函数,
多
个行为封装在一起,单一的函数执行对象的功能太困难,代码太长.
面向过程,就是面向的行为,执行这个行为的过程,面向对象是基于面向过程的.

对象里面,冰箱里面包括了打开关闭存储的功能. 对象里面封装了各种功能.每个功能是单一的行为.面向过程需要一一顺序选择循环
执
行每个行为,就是面向过程,强调行为,面向对象强调对象.  执行者>>指挥者  复杂>>简单
封装,继承,多态.

开发:找对象,建对象,用对象,维护对象之间的关系.
类提取描述了各个对象的特征.
对象就是实实在在的事物,在堆内存中用new产生.

class,描述一个事物,即描述对象的属性和行为.属性即类中的变量,行为即类型中函数方法.
类中包含成员,变量和函数,类调用,用new在堆内存中新建一个类实体.
*/   

//类描述定义对象的特征,用来封装之后创建对象.
class XFeature    //类用来描述对象实体的特征,存在于堆中，类类型对象XFeature.c  //对象特征characteristic=类
{
    String color="red";    //属性成员 color是对象的Member //存在于堆内存中
    int tyre=4;            //属性成员    //成员变量
//打印XFeature的每个成员.
    void run()            //行为成员  //成员函数（方法）
    {
        System.out.println("Print Feature + everyMember: "+"color="+color+" "+"tyre="+tyre);
    }        //类用于封装数据的功能
/*    public static void main(String[] args)
    {
        XFeature c= new XFeature();
        c.tyre=5;
    }   //可以有主函数。*/

}
//对象的各种操作.
class XObject
{
//主函数入口.
    public static void main(String[] args) //入口，用于调用别人
    {
        XFeature c= new XFeature();  //new XFeature()可以直接拿过来用。
        //类类型变量c指向对象实体.对象的属性有默认初始化值,然后再赋显示值
        //改变对象属性,即指挥对象做使用,指挥对象方式:对象.成员
        c.color="yellow";  //对象XFeature.c的成员
        c.run();  //yellow
        XFeature c1= new XFeature();  //建立类XMember的对象实体c1.
        c1.run();  //red
        XFeature c2 = c;  //没有新建实体,c2获取c的值和c一样指向同一个实体.
//可以使用匿名对象new XFeature().run()直接调用成员函数，在堆内存中新建一个无名实体，运行完就找不到了。
//可以使用匿名对象作为实际参数进行传递。不用起名字传递给函数调用。
        changeXFeature(new XFeature()); //匿名直接传递，不用在栈中定义一个对象名字的变量指向//直接使用change函数
        //XFeature c3= new XFeatur();
        //changeXFeature(c3);
        Person p= new Person(); //在没写构造函数的时候调用默认空构造函数。
        //p.age= -20; 访问方式无法访问
        p.speak();
        p.setAge(-3); //需要通过函数访问。
        p.setAge(120);
        Person p1= new Person();  //调用第一个构造函数
        Person p2= new Person("Person2"); //调用第二个构造函数
//构造函数间相互调用this(参数),内部初始化动作.
        Person p3= new Person("Person3", 23); //调用两个参数的构造函数
//新建两个对象,执行了构造代码块.       
        Person p5= new Person("p5",20);
        Person p4= new Person("p4",35);

//调用p5的比较年龄功能,这个功能直接打印出年龄是否相同.       
        p5.compareSay(p4);
        String b= p4.getName();
        System.out.println("-----------------------------------------------------"+b); //外部访问需要用getName,

       

    }
//用于更改XFeature类创建的对象的成员,传进来的对象可以没有名字,
//changeXFeature(new XFeature());但是匿名对象操作完就找不到了.
    public static void changeXFeature(XFeature c)
    {
        c.tyre= 5;
        c.color="black";
        c.run();
    }

}

//封装
//对象的特征Feature。封装Encapsulation(隐藏(透明)对象的属性和实现细节,仅对外提供公共访问的方式)
//将变化隔离,便于使用,提高重用性,提高安全性,
//封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏 ,提供公共方法对其访问.
//函数是Java最小的封装体。（结果）（名字）（参数）{过程不需要理解}；
//类里面的函数有权限：public(共有) private(私有)隐藏，控制访问操作//对访问操作进行限制。
//包，
//框架。
class Person
{
//构造函数是可以被私有化的。private之后的构造函数不能用来初始化对象
//this.关键字，用于区分局部变量和成员变量。
//this.代表本类的对象，（代表它所在函数所属对象的引用）
//哪个对象在调用this.所在函数，this.就属于哪个对象。有时可以省略.
//this语句用于构造函数间互相调用,没"."
   
//构造函数,对象一建立被初始化就有年龄.
    Person(int age)
    {
        this.age=age;
    }
    Person()
    {
        System.out.println("A:I'm "+this.name+" "+"My age ="+this.age);
        cry();
    }
//用于初始化的三种构造函数
    Person(String name)
    {
        this.name=name;
        System.out.println("B:I'm "+this.name+" "+"My age ="+this.age);
        cry();
    }
//构造函数间调用,一个构造函数调用另一个构造函数用this语句.
    Person(String name,int age)
    {
//调用只初始化name的构造函数this(name)初始化了一个对象,而这个对象也是调用本构造函数的同一个对象.
//this语句只能定义在构造函数的第一行.只能用在构造函数内.只能调用一次.
//不允许循环调用,无法初始化,没有结果.
//初始化年龄,调用初始化年龄的构造函数,
        this(name); //只能用一次
        this.age=age;//这也是一个初始化动作,要先执行,必须放在第一行.
        if (age==0)
        {
            System.out.println("C:I'm "+this.name+" "+"My age ="+this.age);
            cry();
        }
        else
            System.out.println("C:I'm "+this.name+" "+"My age ="+this.age);
            System.out.println("I won't cry");
    }

//构造代码块 ,给对象初始化。对象一建立优先于构造函数运行，
//构造函数是给对应的对象初始化，构造代码块给所有的对象统一初始化。
//用来定义对象共性初始化内容。优先执行。

//构造代码块.
    {
        System.out.println("Person structure code piece run"); //initial
    }

/*构造函数*/
//函数名和他所在类名一致。没有定义返回值类型，没有return语句。初始化主函数新建的堆中对象。
//多个构造函数重载，一个类能产生多个对象，每个对象可以对应不同的初始化构造函数。
//当一个类中没有构造函数，系统默认加入一个空参数的构造函数初始化。
//  Person p= new Person();
//    Person()
//    {

//    }   
//默认构造函数，自定义任意一个构造函数，此函数就消失。新建的对象如果没有参数会找不到相应的构造函数。
//构造函数在对象一建立就运行，给对象初始化，一般函数只有调用才执行，给对象添加对象具备的功能，
//一个对象建立，构造函数只运行一次，一般函数可以被调用多次。
//当事物存在就具备一些特性或行为，那么这些内容定义在构造函数中。
//是否需要未知内容参与运算，需要就在构造函数中定义参数。

//定义两个成员变量.
    private int age; //私有仅仅是封装的一种最小体现形式，
    //提供一个访问方式，get or set。//将访问加上一个控制，//提高安全性
    private String name;
    public void setAge(int age)//在提供访问私有变量的方式同时加入限制条件。0-120逻辑判断等语句，提高代码的健壮性
    {
        if (age>=0 && age<=120 )  //a是栈中局部变量
        {
            this.age=age;        //age是堆中新建对象的成员
            speak();
        }
//判断输入的年龄是否正确.
        else if (age>120)
        {
            System.out.println("Parameter's too Big");
            return;
        }
        else if (age<0)
        {
            System.out.println("Parameter's too Small");
            return;
        }
    }   
//提供访问变量的方法.
    public int getAge() //为变量提供的访问方式，这里提供了两种，一种get，一种set
    {
        return this.age;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return this.name;
    }
//成员函数,说出名字和年龄.
    void speak()
    {
        if (this.age==0)
        {
            System.out.println("I'm"+" "+this.name+" My age is "+this.age);
            cry();
        }
        else
            System.out.println("I'm"+" "+this.name+" My age is "+this.age);
    }
//哭的功能.
    public void cry()
    {
        System.out.println("cry......");
    }
//加入比较年龄是否相同的功能.是否是同龄人.
    public void compareSay(Person p)
    {
//this.的应用,定义类中的功能时,该函数内部要用到调用该函数的对象,这是在成员前加this.表示这个对象.
//但凡本类功能内部使用到本类对象,都用this.表示调用该功能的对象.
        if (this.age==p.age)  //自身的年龄是否等于传进来的p.age
        {
           
            System.out.println("My age is the same to "+p.name);
        }
        else
            System.out.println("My age is different to "+p.name);
    }
//--------------------------------------------------------------------------------//
}