/**
 * @author zhaocx1 private:私有权限修饰符，用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效。
 *         注意：私有仅仅是封装的一种表现形式 。 之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。
 *         对访问的数据进行操作，提高代码健壮性。<br />
 *         将age私有化以后，类以外即使建立了对象也不能直接访问。 但是人应该有年龄，就需要在person类中提供对应的访问方式。
 */

public class Person {
	public int age;//定义age属性

	public int getAge() {//定义getAge方法
		return age;//返回一个age
	}

	public void setAge(int a) {//定义setAge方法
		if (a > 0 && a < 130) {
			this.age = a;
		} else {
			System.out.println("false age");
		}
	}

	void speak() {//定义一个函数
		System.out.println("age=" + age);//输出age
	}

	public static void main(String[] args) {//主函数，整个函数的切入点
		Person p = new Person();//实例化Person
		p.setAge(20);//调用setAge方法，并传递一个数值
		p.speak();//调用speak方法
	}
}
/**
 * @author zhaocx1
 *
 */
/*
 * this:看上去，是用于区分局部变量和成员变量的情况。
 * this为什么可以解决这个问题呢？this到底代表的是什么呢？
 * this：就代表本类的对象，到底代表哪一个呢？
 * this代表所在函数所属对象的引用。
 * 简单说：哪个对象在调用 this所在的函数，this就代表哪个函数。
 * 
 * this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。 
 * 但凡本类功能内部使用到了本类对象时，都用this表示。
 */

/*
 * 给人定义一个用于比较年龄是否相同的功能，也就是是否是同龄人。
 * 
 */

class PersonP {
	private String name;//定义name属性
	private int age;//定义age属性

	PersonP(int age) {//对age进行构造函数
		this.age = age;//调用本类对象
	}

	PersonP(String name) {//对name进行构造函数
		this.name = name;//调用本来对象
	}

	PersonP(String name, int age) {//对name和age进行共同构造函数
		this.name = name;
		this.age = age;
	}

	public void speak() {//定义方法
		System.out.println("name=" + this.name + "...age=" + this.age);//输出name和age
		this.show();//调用show函数
	}

	public void show() {//定义show函数
		System.out.println(this.name);//输出name
	}

	/*
	 * 需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。
	 */
	public boolean compare(PersonP p) {//定义功能，对年龄进行判断
		return this.age == p.age;

	}
}

class Person2 {
	public static void main(String[] args) {//主函数，整个程序的切入点

		PersonP p1 = new PersonP(20);//实例化对象
		PersonP p2 = new PersonP(25);//实例化对象
		boolean b = p1.compare(p2);//判断两个年龄是否相同
		System.out.println(b);//输出判断结果

		PersonP p = new PersonP("李四",26);//实例化对象，并传递名字和年龄
		p.speak();
		
	}
}
/**
 * 
 * @author zhaocx1
 *
 */
/*
 * this语句：用于构造函数之间进行调用。
 * this语句只能定义在构造函数的第一行。因为初始化要先执行。
 */
/*
 * Person p=new Person("李四",30)
 * 该句话都做了什么事情？
 * 1.因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。
 * 2.执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
 * 3.在堆内存中开辟空间，分配内存地址。
 * 4.在堆内存中建立对象的特有属性，并进行默认初始化。
 * 6.对属性进行显示初始化。
 * 7.对对象进行对应的构造函数的初始化。
 * 8.将内存地址付给占内存中的p变量。
 * 
 */
class PersonA
{
	private String name;//定义name属性
	private int age;//定义age属性
	PersonA(String name)//构造name函数
	{
		this.name=name;//调用本类对象
	}
	PersonA(String name,int age)//构造name和age函数
	{
		this(name);//调用本类对象
		this.age=age;//调用本类对象
	}
	public static void printMesg(String name,int age)//定义一个函数，传递参数name和age
	{
		System.out.println("我的名字是"+name+", 今年"+age+"岁了。");//输出语句，内容为名字和年龄
	}
}
public class PersonDemo3 {
	public static void main(String[] args)//主函数，整个程序的切入点
	{
		PersonA p=new PersonA("李四",30);//实例化PersonP,并传递姓名和年龄
		p.printMesg("李四",30);
	}
}
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * final:最终。作为一个修饰符。 
 * 1.可以修饰类，函数，变量。
 * 2.被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
 * 3.被final修饰的方法不可以被覆写。
 * 4.被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。
 * 当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读。
 * 而这个值不需要改变，所以加上final。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。 单词间通过_连接。
 * 5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
 * 
 * 目前类上两个修饰符：public final private修饰成员
 */
class Demo {
	final int x = 3;// 定义一个全局整型常量，x的值终身为3，不可以被继承
	final double MY_PI = 3.14;// 定义一个全局小数常量，不可以被继承

	final void show1() {// 定义父类中的方法，被final修饰不可以被子类继承，只能在本来中使用
	}

	void show2() {// 定义父类中的方法
		System.out.println("java");// 输出打印父类方法内容

	}
}

class SubDemo extends Demo {// 定义一个子类继承父类

	void show2() {// 覆写父类中的方法
		System.out.println("android");// 输出打印覆写方法在子类中的内容
	}
}

public class Final1Demo {
	public static void main(String[] args) {// 主函数，整个函数的切入点
		SubDemo su = new SubDemo();// new一个子类对象，进行初始化

		su.show2();// 调用父类中的方法
	}

}