继承，方法重写，super，final关键字

• 继承

 *     子承父业
 * 
 * 为什么要继承:
 *     为了提高代码的服用性
 * 如何使用继承:
 *     子类  extends 父类  使用继承
 * 
 * 注意:
 *         1.子类继承父类,可以使用父类中所有的成员
 *         2.在java中只支持单继承,一个java类可以被多个子类继承的,一个java类只能继承一个父类,但是支持多实现
 * 
 * 单继承的缺点:
 *         不便于后期维护
 * 单继承的优点:
 *         使用简单(加入继承了多个父类,中有限相同的成员,不变化于判断和使用)

public class ExtendsDemo04 {
	public static void main(String[] args) {
		Student s = new Student();
		s.name = "马云";
		s.age = 19;
		s.info();
		s.study();
		s.sleep();

		Teacher t = new Teacher();
		t.name = "因为";
		t.age = 18;
		t.info();
		t.teach();
		t.sleep();
	}
}

// 父类
class Person1 {
	// 名字
	String name;
	// 年龄
	int age;

	// 休息
	public void sleep() {
		System.out.println("休息...");
	}
}

// 教师类
class Teacher extends Person1 {
	// 专业
	String subject;

	// 授课
	public void teach() {
		System.out.println(name + "在传授知识...");
	}

	// 介绍
	public void info() {
		System.out.println(name + "-->" + age + "--->" + subject);
	}
}

// 学生类
class Student extends Person1 {
	// 家乡
	String hometown;

	// 学习
	public void study() {
		System.out.println("学java....");
	}

	// 介绍
	public void info() {
		System.out.println(name + "-->" + age + "--->" + hometown);
	}
}

• 权限修饰符

 * 权限修饰符 : 访问对象中成员的权限范围
 *                         本类            同包类            不同包子类                全部    --从小到大的访问范围
 * private                Y
 * default                Y                  Y
 * protected            Y                  Y                        Y
 * public                 Y                   Y                        Y                     Y
 * 
 * 注意:
 *     1所有的被private修饰的成员都不能再外部访问,也不能被子类继承
 *     2以上所有的权限修饰符都只能修饰成员(方法和成员变量)
 *     3只能用public,default修饰类,default要省略
 * 
 * 父类:基类
 * 子类:派生类
 * 
 * 开闭原则:
 *     对修改关闭,对扩展开放

public class ModifierDemo05 {
	public int a=5;
	protected int b=4;
	int c=3;
	public static void main(String[] args) {
		Sicong s=new Sicong();
		s.test();
		//s.lover="";  私有不可见
	}
}

class Janlin{
	//钱
	public long money=2000000000;
	//小蜜
	private String lover="西施";
	//颜值
	String face="帅";
	//height
	protected double height=180;
	
	//私房钱
	public void sifang(){
		System.out.println("每个月给"+lover+"1000000零花钱...");
	}
}

class Sicong extends Janlin{
	//事业
	public void shiye(){
		System.out.println("熊猫TV...");
	}
	
	public void test(){
		System.out.println("public:"+money);
		//System.out.println("private:"+lover);
		System.out.println("default:"+face);
		System.out.println("protected:"+height);
		ModifierDemo05 m=new ModifierDemo05();
		System.out.println(m.a);
		System.out.println(m.b);
		System.out.println(m.c);
	}
}

• 重写

 * 重写（override）  ---   重载（overload）
 * 重载:同一个类中,不同的方法之间有相同的方法名,不同的参数类表
 * 满足重写的条件:
 *             1.不同的类
 *             2.继承
 *             3.相同的方法签名(方法名+参数列表)
 * 
 *     子类中重写父类中的方法,调用的时候,会对父类的方法进行屏蔽
 *  方法的重写和重载都是针对于方法而言的
 *  
 *  判断重写的依据:
 *      1.左边有一个向上的三角形
 *      2.在方法的上面添加一个注解@Override,用来测试是否重写的方法
 *  
 *  =  : 方法签名
 *  <= : 方法的返回值类型  基本数据类型必须相同 引用数据类型:子类<=父类
 *  >= : 权限修饰符  子类>=父类
 *  
 *  不能被重写的方法:
 *              1.被private修饰的方法不能被重写
 *              2.被final修饰的方法不能被重写
 *              3.被static修饰的方法不能被重写
 *  
 *      注意:如果子父类中有方法签名相同方法,父类中的同名被static修饰了,子类中的方法也要添加static

public class OverrideDemo06 {
	public static void main(String[] args) {
		Sicong1 s = new Sicong1();
		s.speak();
		s.test();
		System.out.println(s.name);

		Jianlin j = new Jianlin();
		j.speak();
		j.test();

	}
}

// 父类
class Jianlin {
	String name = "Jianlin";

	public void speak() {
		System.out.println("先定一个小目标,赚他个一个亿...");
	}

	static Jianlin test() {
		System.out.println("父类");
		return new Jianlin();
	}
}

// 子类
class Sicong1 extends Jianlin {

	String name = "Sicong";

	public void speak(int a) {
		System.out.println("我交朋友从来不在乎他有没有钱,反正都没我有钱...");
	}

	public static Sicong1 test() {
		System.out.println("子类");
		return new Sicong1();
	}

}

• super关键字

 *     super()
 *         调用父类的构造器,会在子类构造器的首行,隐式的调用父类的空构造
 *         显示父类的其他构造器,super(参数列表)
 *         注意:this和super在调用构造器的时候不能同时存在
 *  super.
 *      指代父类对象,区分父类子类中同名成员
 *  
 *  super和this都不能使用在静态的内容中
 *  先父类后子类
 *  在没有显示调用父类构造器的时候,保证父类中有空构造

• final关键字

 *  final 关键字
 *      被final修饰变量为常量----不能改变
 *      被final修饰的方法不能被重写
 *      被final修饰的类不能被继承

• Javabean

 * private关键字 私有成员修饰符 ，不能修饰成员变量
 * 把属性私有化 ，对外提供公共的访问方式，setter和getter
 * 
 * 提高代码复用性，安全性，便于后期维护
 * 
 * private是辅助的一种体现
 * 
 * Javabean编码规则：
 *         必须声明public class
 *         至少存在一个无参构造方法
 *         所有属性必须封装
 *         为封装属性提供公共的访问方式

public class Person {
	String name;
	private int age;

	public Person() {
		// TODO Auto-generated constructor stub
	}

	public void setAge(int age) {
		this.age = age;

	}

	public int getAge() {
		return age;
	}

	public void eat() {
		System.out.println(name + "--->" + age + "--->" + "eat...");
	}
}

class PersonTest {
	public static void main(String[] args) {
		Person p = new Person();
		p.name = "李四";
		p.setAge(18);
		p.eat();
	}
}