面向对象（封装、继承）

1. 封装

1.1 狭义的封装和广泛的封装

狭义的封装
    Java 中定义的类要求符合 JavaBean 规范

广泛的封装
    一段代码使用了三遍，封装一个方法
    一组相关的方法使用了三遍，封装一个类
    一个类使用了三遍，完成完整的开发文档
    开发文档后期阅读了三次，发一篇博客

1.2 Java 符合 JavaBean 规范封装

JavaBean 规范
    规范: 码出规范，码出高效，提高代码的可复用性
要求:
    1. 所有成员变量全部【私有化】
    2. 所有的成员变量提供对应的 【setter and getter】 方法
    3. 必须提供一个无参数构造方法，其他有参数构造方法根据实际所需提供

1.2.1 私有化

使用关键字 private  

public
    公共的，公开的，可以用于修饰成员变量，成员方法，和构造方法
    修饰的内容类外可以根据对应的语法要求直接使用。使用限制较少

private 
    私有的，可以用于修饰成员变量，成员方法，和构造方法
    修饰的内容类外无法直接使用。

 

class Person {
    //public 修饰的公共成员变量 id
    public int id;
    
    //private 修饰的私有化成员变量 num 并且赋值初始化数据 10
    private int num = 10;
}

public class Demo1 {
    public static void main(String[] args) {
        Person person = new Person ();
        
        //通过 Person 类对象 person 操作pubic 修饰成员变量 id 可以使用
        person.id = 10;
        System.out.println(person.id);

		/*
		 * The field Person.num is not visible
		 * Person 类内的成员变量 num 是不可见的，因为 num 使用 private 修饰
		 * 类外无法使用。
		 */
		System.out.println(person.num);

    }
}

1.2.2 this 关键字

针对于目前 this 关键字，主要解决的问题是
    方法参数变量名称和成员变量名称一致的情况下，解决冲突问题。

 

/*
 * 期望方法参数名称带有一定的语义性和指向性，用户可以根据参数变量的名称
 * 了解当前参数到底赋值给哪一个数据
 * 
 * 目前 i n a 参数名称是绝对不允许！！！
 * 
 * 方法参数变量为 id name age 可以更好地给予程序员使用的引导，阅读性更好！
 */
public SingleDog(int id, String name, int age) {
	/*
	 * Java 编译器如果发现参数变量 或者说 方法内部定义的变量和成员变量名称一致
	 * 会采用就近原则，方法内部采用参数变量或者方法自定义变量，操作内容和成员变量
	 * 无关。
	 * 通过代码的颜色也可以发现，当前操作的变量颜色和成员变量颜色不同。
	 * 		id = id;
	 * 		name = name;
	 * 		age = age;
	 * 以上代码错误
	 * 
	 * 【问题】
	 * 	明确赋值号左侧的变量为成员变量
	 * 【解决】
	 * 	使用 this 关键字明确当前操作变量为成员变量，不是方法参数变量
	 */
	this.id = id;
	this.name = name;
	this.age = age;
}

1.2.3 setter and getter 方法

Setter 方法功能:
    setter 方法是给予私有化成员变量进行赋值操作，因为私有化成员变量无法类外直接使用，使用 setter 方法形式规范化赋值操作过程。

格式:
    public void set成员变量名(对应成员变量数据类型参数) {
        赋值成员变量语句;
    }

Getter 方法功能:
    getter 方法是用于获取私有化成员变量数据存储内容，因为私有化变量无法类外直接操作，使用 getter 方法形式规范法取值操作过程。

格式:
    public 对应成员变量数据类型返回值 get成员变量名() {
        return 成员变量;
    }

1.2.4 JavaBean 规范实体类案例

/**
 * 当前类就是符合 JavaBean 规范封装的实体类
 * 		1. 所有成员变量全部私有化
 * 		2. 提供针对于所有成员变量的 Setter and Getter 方法
 * 		3. 必须提供一个无参数构造方法，其他有参数构造方法根据所需完成
 * @author han
 *
 */
class SinglePerson {
	// 成员变量
	private int id;
	private String name;
	private int age;
	
	// 构造方法
	public SinglePerson() {}

	public SinglePerson(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}

	// 针对于私有化成员变量的 setter and getter 方法
	public int getId () {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
	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;
	}
}

public class Demo3 {
	public static void main(String[] args) {
		SinglePerson sp1 = new SinglePerson();

		// 利用 setter 方法进行赋值成员变量操作
		// sp1.id = 1;
		sp1.setId(1);
		sp1.setName("张三");
		sp1.setAge(10);

		// 利用 getter 方法取值类对象私有化成员变量数据存储 
		System.out.println("Id:" + sp1.getId());
		System.out.println("Name:" + sp1.getName());
		System.out.println("Age:" + sp1.getAge());
		
		SinglePerson sp2 = new SinglePerson(23, "李四", 50);
		
		System.out.println("Id:" + sp2.getId());
		System.out.println("Name:" + sp2.getName());
		System.out.println("Age:" + sp2.getAge());
		
	}
}

2. 继承

2.1 Java 中继承的基本语法

关键字：

        extends

格式：

        class A extends B {

        }

    A 类是 B 类的一个子类
    B 类是 A 类唯一父类

Java 中的继承主要关注的是
    1. 类型的延续性，类型的一致性
    2. 方法的传递性和继承

特征:
    1. 子类可以通过继承得到父类中的非私有成员变量和成员方法的使用/操作权利
    2. 子类不可以通过该继承得到父类中的私有化成员变量和成员方法

2.2 继承语法演示案例代码

class SuperClass {
	// public 修饰的成员变量和成员方法
	public int num = 10;
	
	public void game() {
		System.out.println("Coding~~~");
	}
	
	// private 修饰的成员变量和成员方法
	private int ret = 20;
	
	private void uniqueTech() {
		System.out.println("绝活！！！");
	}
}

/*
 * exntends 关键字完成继承操作
 * SubClass 是 SuperClass 的一个子类
 * SuperClass 是 SubClass 的唯一父类
 * 
 * 子类没有任何的内容！！！
 */
class SubClass extends SuperClass {
	
}

public class Demo1 {
	public static void main(String[] args) {
		SubClass sc = new SubClass();
		
		// 子类对象可以通过继承得到父类 public 修饰的成员变量和成员方法
		System.out.println(sc.num);
		sc.num = 20;
		System.out.println(sc.num);
		
		sc.game();
		
		// 通过子类对象调用父类私有化成员变量和成员方法，报错！！！本身子类不具备对应方法， 同时
		// private 修饰的私有化内容类外无法使用
		// The field SuperClass.ret is not visible
		// SuperClass 类内的 private 修饰成员变量 ret 不能被访问
		// System.out.println(sc.ret);
		
		// The method uniqueTech() from the type SuperClass is not visible
		// SuperClass 类内的 private 修饰成员方法 uniqueTech() 不能被 访问
		// sc.uniqueTech();
	}
}

2.3 继承带来的问题

        父类方法可以通过继承交给子类使用，但是有可能无法满足子类的特殊情况，如果子类重新自定义方法，会导致开发使用的方法过多，方法冗余，开发压力大。

合理合适的解决方案:
    重写:
        1. 必须存在继承关系
        2. 子类重写父类方法，要求方法的声明必须一致
        3. 子类可以根据特征需求，重新完成方法体实现，满足自身需求
        4. 必须使用 @Override 注解(注释+解释) 开始重写代码格式严格检查，如果子类重写父类方法，方法声明不一致，【语法报错】无法编译通过。
    优势:
        1. 降低了开发压力，不必要准备过多的方法，子类和父类使用的方法声明一致。
        2. 又可以个性化的满足当前类的实际情况

2.4 重写代码案例

 

class Father {
	public void game() {
		System.out.println("黄金矿工，捕鱼达人");
	}
	
	public void work() {
		System.out.println("机械工程师");
	}
}

/*
 * Son 类是 Father 类的子类，可以继承得到父类中 public 修饰的成员方法
 * 
 * 目前子类没有任何内容
 * 子类对象可以使用父类的方法，但是父类的方法执行的目标/效果，不满足，不合适
 * 子类的特殊情况。
 * 
 * 继承是可以增强方法延续性，但是父类的方法有可能不满足子类的实际情况。
 * 
 * 方案1:
 * 	子类不考虑使用父类方法，自定义方法描述自身行为
 * 方案 1 弊端:	
 * 	会导致开发压力巨大！！！需要记忆的方法很多，导致代码冗余，不便于开发操作
 * 
 * 重写！！！
 */
class Son extends Father {
	/*
	 * 子类重写了父类的 game 方法，同时根据自身情况，修改了方法体实现，满足自身需求
	 */
	@Override
	public void game() {
		System.out.println("PUBG LOL WOT");
	}
	
	@Override
	public void work() {
		System.out.println("非正经讲师");
	}
}

public class Demo2 {
	public static void main(String[] args) {
		Son son = new Son();
		
		son.game();
		son.work();
	}
}