今日内容：
继承
继承：
1.场景：
如果多个类存在相同的属性和行为时，将这些内容抽取到单独一个类中，
那么多个类无需再定义这些属性和行为，只要继承那一个类即可。
其中，多个类可以称为子类，单独的那个类称为父类、超类、基类
继承描述的是事物之间的所属关系，这种关系是：is-a的关系。
父类更通用，子类更具体。我们主要是通过继承，可以使事物之间形成一种关系体系。
2.定义：
就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。
子类可以直接访问父类中的非私有的属性和行为。
3.好处：
1.提高代码的复用性。
2.使得类与类之间产生了关系，是多态的前提。
4.继承格式：
通过关键字extends，可以声明一个子类继承另一个父类
class SuperClass{
....
}
class Subclass extends SuperClass{
....
}
5. 继承后的特点---成员变量
1.成员变量不重名
如果子类父类中出现不重名的成员变量，这时访问时没有影响的。
如果重名，这时访问是受影响的。
子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量，就需要使用super关键字，
修饰父类成员变量，类似于关键字this
2.使用格式：
super.父类成员变量名;
备注：父类中的成员变量是非私有的，子类才可以直接访问。若父类中的成员变量私有了，子类不能直接访问的。
通常编码时，我们一般遵循封装的原则，可以在父类中提供公共的setXxx()和getXxx()方法。
6. 继承后的特点---成员方法
1.成员方法不重名
如果子类父类中出现不重名的成员方法时，这时的调用没有任何的影响。
对象调用方法时，会先在子类中查找有没有对应的方法，若子类存在就会执行子类中的成员方法，
若不存在就会执行父类中相应的方法。
2.成员方法重名---重写(Override)
方法重写：子类出现于父类一模一样的方法时(返回值类型，方法名和参数列表都相同)，会出现覆盖效应
也称为重写或者复写。声明不变，重新实现。
3.重写的应用
子类可以根据需要，定义特定于自己的行为，即沿袭了父类的功能名称，又能根据子类的需要重新实现父类
的方法，从而进行扩展增强。比如：新的手机来电显示功能。
备注：
1.子类方法重写覆盖父类方法时，必须保证权限大于等于父类的权限。
2.子类方法重写父类方法时，返回值类型，方法名和参数列表必须一模一样。
在没有使用@Override时，子类定义父类方法时，方法名和参数列表可变，返回值类型不可变。
7. 继承的特点：
1.java只支持单继承，不支持多继承。
2.java支持多层继承(继承体系)
3.子类和父类是一种相对概念。
备注：顶层父类是Object类，所有的类默认都继承Object类。
抽象类：
本质就是类
异同点：
使用场景：
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，
只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。
Java语言规定，包含抽象方法的类必须是抽象类。
定义：
抽象方法：没有方法体的方法。
抽象类： 包含抽象方法的类。
抽象方法和抽象类的声明需要用到关键字abstract(抽象的)。
如果一个成员方法被abstract关键字修饰，那么该方法就是一个抽象方法，抽象方法只包含一个方法名，
而没有方法体。
定义格式：
修饰符 abstract 返回值类型 方法名(参数列表);
如：
public abstract void eat(double money);
抽象类
如果一个类包含了抽象方法，那么该类必须是抽象类
定义格式：
public abstract class ClassName {
//.....
......
}
抽象的使用：
继承抽象类的子类必须重写父类中的所有的抽象方法，否则该子类也必须声明为抽象类。
最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去了意义。
抽象类一般被设计成父类使用的。
TestExtends
package com.buli.Extends;
public class TestExtendsDemo01 {
public static void main(String[] args) {
// 构建一个Teacher类的对象
Teacher teacher = new Teacher();
// 给该员工类的name属性进行赋值
//teacher.name = "小明";
// 调用该员工类的printName方法
teacher.printName();
teacher.job();
teacher.work();
}
}
Teacher
package buli.Extends;
// 定义讲师类Teacher 继承 员工类 Employee
public class Teacher extends Employee{
// 在子类中再次定义name属性
String name = "小王";
// 定义一个打印name的方法
public void printName() {
System.out.println("name = " + super.name);
System.out.println("name = " + this.name);
}
// 重新再次定义一个work方法 增强编译性
public void work() {
}
// 定义一个工作的方法
public void job() {
System.out.println("开心的快乐的工作着。。。");
}
// 定义一个打印age的方法
public void printAge() {
//System.out.println("age = " + age);
}
}
Super
package buli.Extends;
/*
* super关键字 父，超，基
* 定义：子类对父类的引用，只能在非静态方法中使用。
* 1.引用父类的成员变量时 格式为：super.成员变量名
* 2.引用父类的非静态方法时，格式为：super.方法名(参数列表)
* 3.引用父类的构造方法时， 格式为：super(参数列表);
* super(参数列表)只能在构造方法中使用，而且必须是构造方法的第一条语句。
*/
public class SuperDemo extends Employee{
String name = "小王";
// 普通的成员方法
public void method() {
System.out.println(this.name);
super.name = "张三";
}
public void method02(String name) {
super.name = name;
System.out.println(super.name);
}
public SuperDemo() {
super();
System.out.println("我要开始构造对象了。。。");
}
// Constructor call must be the first statement in a constructor
public void method03() {
//super();
}
public static void main(String[] args) {
// 只能通过对象访问
SuperDemo superDemo = new SuperDemo();
//superDemo.method();
superDemo.method02("王五");
//System.out.println(this.name);
}
}
static
package com.buli.Extends;
// static关键字 单行注释
/*
多行注释
*/
/**
文档注释
1.static关键字 可以用来修饰成员变量和成员方法，不能用来修饰类
被修饰的成员是属于类的，而不单单是属于某一个对象的，将来调用这些被static修饰的成员信息，
可以不再通过对象来调用。
2.当static修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。
任何对象都可以更改该类变量的值，但也可以在不创建对象的情况下对类变量进行操作。
定义格式：
static 数据类型 变量名; 如 static String name = "小刘";
3.当static修饰成员方法时，该方法被称为类方法。也习惯称为静态方法。
定义格式：
修饰符 static 返回值类型 方法名(参数列表) {
//方法体内容
.....
}
类方法调用时细节：
1.静态方法可以直接访问类变量和类方法
2.静态方法不能直接访问普通的成员方法和成员变量。反之，成员方法可以直接访问类变量和类方法。
3.静态方法中，不能使用this关键字和super关键字。
4.被static修饰的方法，建议通过类名直接调用，也可以通过对象名来调用，但是程序出现警告信息。
*/
public class StaticDemo extends Employee{
static String name = "小刘";
public void eat() {
System.out.println("我在美美的吃大餐。。。");
}
public static void main(String[] args) {
//super.work();
//this.eat();
StaticDemo s1 = new StaticDemo();
s1.name = "小王";
System.out.println("s1的name值为："+s1.name);// 小王
StaticDemo s2 = new StaticDemo();
System.out.println("s2的name值为："+s2.name);// 小刘
StaticDemo s3 = new StaticDemo();
System.out.println("s3的name值为："+s3.name);// 小刘
StaticDemo s4 = new StaticDemo();
System.out.println("s4的name值为："+s4.name);// 小刘
}
Permissions
package buli.Extends;
public class PermissionsDemo {
/* 权限修饰符
*
* public protected 不写(默认的) private
*
* 访问范围：
* 当前类中
* 同包下不同类中
* 不同包无关类
* 不同包的子类
*/
}
Managers
package buli.Extends;
public class Managers {
double salary;
}
Employee
package com.zhiyou100.Extends;
// 员工类 父类
public class Employee extends Human{
//成员变量
String name = "小刘";
private int age;
//成员方法
protected void work() {
System.out.println("尽心尽力的工作。。");
}
}
Final
package buli.Extends;
/*
* final关键字： 最终的，最后的
* 特点：
* 1.当final关键字修饰类的时候，这个类不能被继承，但是不影响对象的创建如String类
* 2.当final关键字修饰方法的时候，这个方法不能被重写，但是父类中的没有被final修饰的
* 方法，子类覆盖后可以添加final关键字。
* 3.静态的方法重写后一般只能是静态的，非静态的方法重写后一般只能非静态的。
* 4.final修饰局部变量，只能够赋值一次。当修饰的是引用的类型的时候，不能被重新赋值
* 但是可以修改对象的属性
* 全局变量是声明在类内部方法外部。
* 局部变量一般声明方法内或者代码块中。
* 5.final修饰成员变量，必须在定义的时候进行赋值，不会有自动初始化值(在构造方法中进行赋值)
*/
public class FinalDemo {
final String name;
public FinalDemo() {
name = "李四";
}
public static void work() {
System.out.println("我在上课。。。");
}
String[] args;
/*{
String[] args;
if (1== 2) {
String[] args;
}
}*/
public static void main(String[] args) {
final String name;
final int[] arr = {10,20,30};
arr[0] = 50;
final int age = 18;
//String[] args;
if (1 != 2) {
//String[] args;
}
//name = "李四";
//age = 20;
}
}
class Zi extends FinalDemo{
public static void work() {
System.out.println("我在吃饭。。。");
}
}