//匿名对象_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);
}
}