/*面向对象强调的是对象,
面向过程强调的是功能行为,打开行为,关闭行为,执行行为,把多个行为封装成对象执行更强大的功能就是面向对象,是把多个函数,
多
个行为封装在一起,单一的函数执行对象的功能太困难,代码太长.
面向过程,就是面向的行为,执行这个行为的过程,面向对象是基于面向过程的.
对象里面,冰箱里面包括了打开关闭存储的功能. 对象里面封装了各种功能.每个功能是单一的行为.面向过程需要一一顺序选择循环
执
行每个行为,就是面向过程,强调行为,面向对象强调对象. 执行者>>指挥者 复杂>>简单
封装,继承,多态.
开发:找对象,建对象,用对象,维护对象之间的关系.
类提取描述了各个对象的特征.
对象就是实实在在的事物,在堆内存中用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);
}
//--------------------------------------------------------------------------------//
}