java 成员对象 丢失_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);

}

//--------------------------------------------------------------------------------//

}