面向对象进阶

public class Demo1{
	public static void main(String args[]){
		Person per = new Person();
		per.name = "张三";
		per.age = -30;
		per.tell();
	}
};

class Person{
	String name; // 表示姓名
	int age; // 表示年龄
	void tell(){
		System.out.println("姓名：" + name + "；年龄：" + age);
	}
};

运行结果：姓名：张三；年龄：-30

以上的操作代码并没有出现了语法错误，但是出现了逻辑错误 （年龄-30岁）
在开发中， 为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作。
修改代码如下：

public class Demo1{
	public static void main(String args[]){
		Person per = new Person();
		per.setName("张三") ;
		per.setAge(-30) ;
		per.tell();
	}
};

class Person{
	private String name ; // 表示姓名
	private int age ; // 表示年龄
	void tell(){
		System.out.println("姓名：" + getName() + "；年龄：" + getAge()) ;
	}
	public void setName(String str){
		name = str ;
	}
	public void setAge(int a){
		if(a>0&&a<150)
			age = a ;
	}
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
};

运行结果：姓名：张三；年龄：0 

在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：
· 调用类中的属性
· 调用类中的方法或构造方法
· 表示当前对象

public class Demo3 {

	public static void main(String[] args) {
		Person3 p1 = new Person3("张三",18);
		Person3 p2 = new Person3();
		p1.say();
		p2.say();
	}

}


class Person3 {
	private String name;
	private int age;
	//p2对象
	Person3() {
		this("默认姓名",1);
	}
	//p1对象
	Person3(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	void say() {
		System.out.println("自我介绍：我是"+name+",我的年龄："+age);
	}
}

 运行结果：自我介绍：我是张三,我的年龄：18
                   自我介绍：我是默认姓名,我的年龄：1

static表示“静态”的意思，可以用来修饰成员变量和成员方法(后续还会有 静态代码块 和 静态内部类)。
static的主要作用在于创建独立于具体对象的域变量或者方法
简单理解：
被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
并且不会因为对象的多次创建 而在内存中建立多份数据 

1. 静态成员 在类加载时加载并初始化。
2. 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
3. 在访问时： 静态不能访问非静态 , 非静态可以访问静态 ! 

public class Demo4 {

	public static void main(String[] args) {
		Emp.region = "北京";
		Emp e1 = new Emp("张三");
		Emp e2 = new Emp("李四");
		Emp e3 = new Emp("王二");
		Emp e4 = new Emp("麻子");
		e1.say();
		e2.say();
		e3.say();
		e4.say();
		//假设：公司迁址，天津
		Emp.region = "天津";
		e1.say();
		e2.say();
		e3.say();
		e4.say();
	}

}

class Emp {
	private String name;
	static String region;
	
	Emp(String name,String region) {
		this.name = name;
		this.region = region;
	}
	
	Emp(String name) {
		this.name = name;
	}
	
	Emp() {}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getRegion() {
		return region;
	}
	public void setRegion(String region) {
		this.region = region;
	}
	
	void say() {
		System.out.println("员工姓名："+name+",员工所在地区："+region);
	}
}

 运行结果：

员工姓名：张三,员工所在地区：北京
员工姓名：李四,员工所在地区：北京
员工姓名：王二,员工所在地区：北京
员工姓名：麻子,员工所在地区：北京
员工姓名：张三,员工所在地区：天津
员工姓名：李四,员工所在地区：天津
员工姓名：王二,员工所在地区：天津
员工姓名：麻子,员工所在地区：天津

普通代码块
在执行的流程中出现的代码块， 我们称其为普通代码块。
构造代码块
在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。
静态代码块
在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会执行一次的代码块。
同步代码块
在后续多线程技术中学习。
面试题：
构造方法 与 构造代码块 以及 静态代码块的执行顺序：
静态代码块 --> 构造代码块 --> 构造方法

public class Demo7 {

	public static void main(String[] args) {
		
		{
			int a = 10;
			System.out.println(a);
		}
		Person4 p1 = new Person4();
		Person4 p2 = new Person4();
	
	}

}

class Person4 {
	private String name;
	private int age;
	
	{
		System.out.println("对象创建时执行1");
	}
	
	static {
		System.out.println("静态代码块执行");
	}
	public Person4() {
		System.out.println("对象创建时执行2");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	void say() {
		System.out.println("姓名："+name+",年龄："+age);
	}
}

运行结果：

10
静态代码块执行
对象创建时执行1
对象创建时执行2
对象创建时执行1
对象创建时执行2