检测继承性，super的用法，方法的重写，final，静态static。以及多态
开门见山。在一片空白里，利用自己看的理论知识，进行逐一枚举并验证。只有当你能在一篇空白里利用所学，运用所思，尽可能的归纳并以某种形式表达出来，或是策划方案，或是代码，或是文章，这时才能在理解之上建立记忆，而不是在虚无之中制造懵懂。
检测继承性，super的用法，方法的重写，多态等
//检测继承性，super的用法，方法的重写,多态
//关于继承的目前总结
public class Test0001 {
public static void main(String[] args) {
//new父类对象
Father F1 = new Father();//new一个父类对象F1,同时执行了父类的无参构造方法
System.out.println(F1.a);
F1.a = "java";
System.out.println(F1.a);
Father F2 = new Father("呕吼");//new一个父类对象F2，同时执行了父类的含参构造方法
F2.age(50);
F2.eat();
//new子类对象
Son s1 = new Son();//new一个子类对象s1，同时执行子类的无参构造方法以及该方法里默认的或者修改后的父类构造方法
s1.eat();//检测子类对父类的方法重写
s1.study();
//
Son s2 = new Son(18);//new一个子类对象s2，同时执行子类的含参构造方法以及该方法里默认的或者修改后的父类构造方法
System.out.println(s2.a);//子类可以继承使用父类的属性（非私有的）
System.out.println(s2.c);
s2.age(26);//子类可以使用父类的方法（非私有的）
//下面看多态的检测
/*
多态是在继承的前提下，并且有方法的重写
*/
Father F3 = new Son();//F3是父类Father的类型，但是它是指向子类Son的对象，也就是向上转型
F3.age(50); //可以调用父类的功能，F3就是父类的
F3.eat(); //得到子类的，说明可以调用子类重写的父类功能
// F3.study(); 这里会报错，说明向上转型的情况下，不能调用子类特有的功能
System.out.println(F3.b);//999 多态情况下，调用的成员变量是父类的
F3.drink();//飞天茅台。同样的静态资源，调用的是父类的
/*
多态是在继承的前提下，并且有方法的重写
多态是为了统一调用标准，向父类看齐
*/
}
}
//创建父类 Father
class Father{
//父类的成员变量
String a;
int b = 999;
//父类的构造方法。默认会有无参构造方法，可以写出来进行修改
public Father(){
System.out.println("Father的无参构造方法");
}
public Father(String a){
System.out.println("Father的含参构造方法"+a);
}
//创造普通方法描述功能
public void eat(){
System.out.println("吃个酸菜鱼吧~~");
}
//私有的资源，子类无法访问，无法使用
private void work(){
System.out.println("年薪"+b+"万");
}
public int age(int c){
work();//在公共的方法里调用私有的方法
return c;
}
//创建一个静态方法
public static void drink(){
System.out.println("飞天茅台");
}
}
//创建子类 son
class Son extends Father{
// 成员变量
int b = 666;
int c = 6;
//子类的构造方法
public Son(){
//super() 这里第一行其实默认有个super来执行父类的无参构造方法
//不写的时候，默认在new子类对象时，先执行父类的无参构造方法，然后执行自己的构造方法
System.out.println("子类son的无参构造方法");
}
public Son(int a){
//可以用super具体使用父类的特定构造方法
super("哈哈哈");
System.out.println("子类son的含参构造方法"+a+" 同时验证super调用父类构造方法的执行");
}
//创造子类son 的普通方法
//方法的重写override：返回值类型 方法名 参数列表和父类的方法一样
//重写时，对应的子类方法的权限要 大于等于 父类的方法权限
//重写的方法不对父类的方法源码进行修改，而是进行功能的修改与扩展
public void eat(){
System.out.println("再吃个"+c+"斤龙虾吧！！");
}
//子类自己的方法
public void study(){
System.out.println(super.b);//子类与父类的变量b重名了，用super调用父类的变量b
System.out.println("滚去学习");
}
//创建一个静态方法
//静态static，它既然和类一起加载，静态资源属于类，哪怕方法的声明相同，也不算是方法的重写
public static void drink(){
System.out.println("夺命大乌苏");
}
}
/*
* 关于final：
* 被final修饰的类，不能被继承
* 被final修饰的方法，不能被重写
* 被final修饰的变量是个常量，值不能被改变
* 常量的定义形式：final 数据类型 常量名 = 值
*/
检测static
package cn.jhf.study;
//检测static
public class TestOopStatic {
public static void main(String[] args) {
System.out.println(Cat.name);//类名可以直接调用static修饰的变量name
//new 一个 miao1 对象
Cat miao1 = new Cat();
miao1.age = 1;//把数值1赋值给整数型变量age
System.out.println(miao1.age);
System.out.println(miao1.breed);
miao1.play();
miao1.name = "雪碧";//给name赋值
System.out.println(miao1.name);
System.out.println(Cat.name);
miao1.eat();
Cat.eat();//类名可以直接调用static修饰的方法eat()
//new个新对象
Cat miao2 = new Cat();
//name经过static静态修饰，全局唯一。在miao1对象里赋值了“雪碧”，所以miao2对象直接调用name时也是”雪碧“
System.out.println(miao2.name);
//age没有经过static修饰，即便上面的miao1对象给age赋值了，但是新的对象依然调用类里原始的值
System.out.println(miao2.age);
miao2.eat();
}
}
class Cat{
//Cat的成员变量
static String name;//用static修饰该变量
int age;
String breed = "英短蓝猫";
//用static修饰方法
public static void eat(){
System.out.println("营养膏");
}
public void play(){
System.out.println("逗猫棒");
}
}
/*
static:
综合之前的例子，目前所知static:
1.与类同生同释。类加载的时候，static就同时加载了，只加载一次，就会一直存在，直到类消失了，它也就消失了。它优先于对象加载。
2.从上面可以看出，static可以修饰变量，也可修饰方法。
3.静态static既然和类一起加载，静态资源属于类，哪怕方法的声明相同，也不算是方法的重写
4.因为static优先于对象加载，所以不能和this或者super共用。有static时，可能还没有对象。
5.静态只能调用静态，非静态可以随意调用。
什么意思呢，就是静态修饰的内容如果要调用变量或者方法，只能调用也被静态修饰的变量或者方法。
而非静态修饰的内容想要调用变量或者方法，可以随意调用被静态修饰的东西，也可调用没有被静态修饰的非静态东西。
6.从上面可以看出，静态的可以被类名直接调用
*/
