面向对象进阶

封装 private

我们观察如下代码

class Person{
private String name ; // 表示姓名
private int age ; // 表示年龄
void tell(){
System.out.println("姓名：" + name + "；年龄：" + age) ;
}
};
public class Demo{
public static void main(String args[]){
Person per = new Person() ;
per.name = "张三" ;
per.age = -30 ;
per.tell() ;
}
};

以上的操作代码并没有出现了语法错误，但是出现了逻辑错误 （年龄-30岁）

在开发中， 为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得
操作。

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 ;
}
};
public class OODemo10{
public static void main(String args[]){
Person per = new Person() ;
2.2、this
2.3、static
概述
重点：
per.setName("张三") ;
per.setAge(-30) ;
per.tell() ;
}
};

this

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

在一个构造方法中，调用另一个构造方法时，调用的代码必须编写在构造方法的第一行
· 表示当前对象

Person2 p1 = new Person2("张三",18);
		Person2 p2 = new Person2("李四",18);
		p1.say();
		p2.say();
		
		Person2 p3 =new Person2();
		p3.say();

	}

}
/**
 * this指的是当前对象
 * @author 23802
 *
 */
class Person2{
	private String name;
	private int age;
	
	Person2(){
		this("无名之辈",110);
	}
	
	Person2(String name,int age){
		this.name = name;
		this.age = age;
	}
	void say() {
		System.out.println("姓名:"+name+"年龄:"+age);     
	}
}

static静态

被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。并且不会因为对象的多次创建 而在内存中建立多份数据

重点:

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

package secondSecond;

public class Demo5 {

	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();
		System.out.println(Emp.count);
	}

}

class Emp{
	private String name;
	static String region;
	static int count;
	
	Emp(){
		count++;
	}
	
	Emp(String name,String region){
		count++;
		this.name = name;
		this.region = region;
	}
	
	Emp(String name){
		count++;
		this.name = name;
		
	}
	
	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 void say() {
		
		System.out.println("待到秋来九月八,我花开后百花杀");
	}
	void say2() {
		System.out.println("冲天香阵透长安，满城尽带黄金甲");
		say();
	}

代码块

package secondSecond;

public class Demo7 {

	public static void main(String[] args) {
		/**
		 * 编写在顺序执行的代码流程中的代码块
		 */
		 {
			//int a = 10;
			//System.out.println(a);
		}
		 Poo p1 = new Poo();
		 Poo p2 = new Poo();
	}

}

class Poo{
	private String name;
	private String age;
	
	/**
	 * 构造代码块,随着对象的每次创建,执行一次.且执行在构造方法之前
	 * 区别于构造方法的是:
	 * 无论用户调用哪一个构造方法创建对象,构造代码块都必然执行
	 */
	
	{
		System.out.println("对象创建时执行1");
	}
	
	/**
	 * 静态代码块,随着类的加载(第一次使用),静态代码块只执行一次.
	 * 因为类只加载一次,所以静态代码块只执行一次.
	 */
	static {
		System.out.println("静态代码块执行");
	}
	
	
	public Poo() {
		System.out.println("对象创建时执行2");
	}
	
	public Poo(String name) {
		System.out.println("对象创建时执行2");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	void say() {
		System.out.println("名字:"+name+"年龄"+age);
	}
}

main方法

· public：表示公共的内容，可以被所有操作所调用
· static：表示方法是静态的，可以由类名称直接调用。java StaticDemo09
· void：表示没有任何的返回值操作
· main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main
· String[] args：字符串数组，接收参数