Java基础---super关键字，方法重写 ，instanceof关键字

/*super关键字：


super关键字代表了父类空间的引用.


super关键字的作用：


   1.子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
   2.创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。




super关键字调用父类构造方法要注意的事项：


1，如果在子类的构造方法上没有指定调用父类的构造方法，那么Java编译器会在子类的构造方法上面加上super（）语句的。
2.super关键字调用父类的构造函数时，该语句必须是子类构造函数中的第一个语句。
3.super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要放在第一个语句。


super关键字与this关键字的区别：
     1.代表的事物不一致。
    1.super关键字代表的是父类空间的引用。
2.this关键字代表的是所属函数的调用者对象


     2.使用的前提不一致
    1.super关键字必须有继承关系才能使用。
2.this关键字不需要存在继承关系也可以使用。
3.调用的构造函数的区别：
    1.super关键字是调用父类的构造函数。
2.this关键字是调用本类的构造函数。
*/


class Fu
{
int x = 10;
String name;


public Fu(){
System.out.println("Fu类无参的构造方法");

}




public Fu(String name){
this.name = name;
System.out.println("Fu类带参的构造方法");

}


public void eat(){
System.out.println("小头爸爸吃番薯.." );

}
}


class Zi extends Fu
{
int x=20;
public void eat(){
System.out.println("大头儿子吃龙虾" );
}




    public Zi(String name){
this();//调用本类无参的构造方法
this.num = num;
//super(name);//指定调用父类带参的构造方法。。。
//super();//指定调用了父类无参的构造方法。。。
System.out.println("Zi类带参的构造方法");

}


public Zi(){
System.out.println("Zi类无参的构造方法");

}
public void print(){
super.eat();
System.out.println("x= " +super.x);

}
}


class Demo9 
{
public static void main(String[] args) 
{
Zi z=new Zi("狗娃");
z.print();


}

}

/*
目前的问题：父类的功能无法满足子类的需求。


方法的重写：子父类出现了同名的函数，这个就称作为方法的重写


什么时候使用方法的重写：父类的功能无法满足子类的需求。


方法重写要注意的事项：


1.方法重写时，方法名，形参列表必须一致；
2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符
3.方法重写时，子类的返回值类型必须要小于或者等于父类的返回值类型
4.方法重写时，子类抛出的异常类型小于或者等于父类抛出的异常类型


Exception(最坏)
RuntimeException(小坏)


方法的重载：在一个类中存在两个或者两个以上的同名函数，称作为方法的重载


方法重载的要求：
  1.函数名要一致
  2.形参列表不一致（形参的个数或形参的类型不一致）
  3.与返回值类型无关


*/


class Animal{//大的数据类型
}


class Fish extends Animal{//Fish小的数据


}
class Fu{


String name;


public Fu(String name){
this.name = name;

}
public Animal eat() throws Exception{
System.out.println(name+"吃番薯...");
return new Animal();
}
}


class Zi extends Fu
{
String num;
public Zi(String name){
//指定调用父类带参的构造方法
super(name);

}


//重写父类的eat方法
public Animal eat() throws RuntimeException{
System.out.println("吃点开胃菜");
System.out.println("喝点汤");
System.out.println("吃青菜");
System.out.println("吃点龙虾...");
System.out.println("吃两杯");
System.out.println("吃点甜品");
return new Fish();

}
}


class Demo10 
{
public static void main(String[] args) 
{
Zi z= new Zi("大头儿子");
z.eat();
}
}

/*
需求：使用java描述一下普通的学生，Java基础班的学生，就业办的学生。


所有的学生都会学习，但是学习的内容不一样


普通的学生：马克思列宁主义。
基础班的学生：学习的是javase.
就业班的学生：javaee+android
*/




class Student
{
String name;
//构造函数
public Student(String name){
this.name = name;

}
public void study(){
System.out.println(name+"学习马克思列宁主义");

}
}


//基础班的学生属于学生中的一种


class BaseStudent extends Student
{
public BaseStudent(String name){
super(name);//指定调用父类构造函数

}


//重写


public void study(){
System.out.println(name+"学习javase");

}
}


//就业班学生 也是属于普通学生中的一种
class WorkStudent extends Student{


//构造函数
public WorkStudent(String name){


super(name);

}
//重写


public void study(){
super.study();
System.out.println(name+"学习javaee+android");
}

}
class Demo11 
{
public static void main(String[] args) 
{
BaseStudent s= new BaseStudent("居东东");
s.study();
//创建一个就业班的学生


WorkStudent w = new WorkStudent("张三");
w.study();
}
}

/*
instanceof关键字


instanceof关键字的作用：判断一个对象是否属于指定的类别。


instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者接口的关系（接口）


instanceof关键字的使用格式：


对象  instanceof 类别




instanceof关键字的作用：目前没有用。但是后天我们学到了多态之后就非常有用。
一般我们做强制类型转换之前都会都会使用该关键字先判断一把，然后再进行转换。
*/




class Animal 
{
String name;
String color;
public Animal(String name,String color){
this.name  = name;
this.color = color;

}
}


//狗属于动物中的一种


class Dog extends Animal
{
public Dog(String name,String color){
super(name,color);//指定调用父类的两个参数的构造函数。

}
public void bite(){
System.out.println(name+"咬人！！");

}
}


//老鼠也是属于动物中的一种
class Mouse extends Animal
{
public Mouse(String name,String color){
super(name,color);

}


public void dig(){
System.out.println(name+"打洞");

}
}
class Demo12 
{
public static void main(String[] args) 
{
Dog d = new Dog("哈士奇","白色");
System.out.println("狗是够类么？"+(d instanceof Dog));
System.out.println("狗是够类么？"+(d instanceof Animal));


//System.out.println("狗是够类么？"+(d instanceof Mouse));//报错的，不存在继承关系


d.bite();


Animal a = new Animal("狗娃","黄色");
System.out.println("动物都是狗么？"+(a instanceof Dog));
}
}

复习

/*
static（静态，修饰符）


static修饰成员变量：如果一个成员变量使用static修饰，那么该成员变量就是一个共享数据。


静态成员变量的访问方式


    方式1：可以使用对象访问。
   对象.属性名
方式2：可以使用类名访问。
   类名.属性名


注意：非静态成员变量不能使用类名直接访问，要使用对象访问


      2.千万不要为了访问方便而使用static修饰。一定要数据真正是需要被共享的时候才能使用static修饰。


static修饰成员函数：
静态函数的访问方式


    方式1：可以使用对象访问。
   对象.属性名
方式2：可以使用类名访问。
   类名.属性名


推荐使用类名访问静态成员。


静态函数要注意的细节：
  1.非静态函数只能由对象调用，静态函数可以由类名或者对象进行调用
  2.静态函数中不能直接访问非静态成员，可以直接访问静态的成员。
  3.非静态函数可以直接访问非静态成员以及直接访问静态成员。
  4.静态函数中不能出现this或者super关键字




单例设计模式：保证一个类在内存中只有一个对象


饿汉单例设计模式：


    1.私有化构造函数。
2.声明本类的引用类型变量并且指向本类的对象（private static）
3.提供一个公共静态的方法获取本类对象。


懒汉单例设计模式：
    1.私有化构造函数
2.声明本类的引用类型变量，但不要创建对象。
3.提供一个公共静态的方法获取本类对象，获取之前先判断是否已经创建了本类对象。
如果没有创建，创建再返回。如果已经创建了直接返回即可




继承：
 继承的格式：


 class 类名1 extends 类名2{}




继承要注意的事项：


1.父类的私有成员不能被继承
2.父类的构造函数不能被继承。
3.创建子类对象时，默认会调用父类无参的构造函数，然后再调用子类的构造函数。


super 关键字：super关键字代表的是父类引用空间。


super关键字的作用：
  1.如果子父类存在同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字访问父类的成员
  2.创建子类对象时，默认会先调用父类无参构造函数，可以通过super关键指定调用父类的构造函数。


  super关键字要注意的事项：


  1.如果在子类的构造函数中没有指定具体的父类构造函数，那么java编译器会在子类的构造函数上super（）
  2.super关键字调用构造函数是必须出现在构造函数中的第一个语句。
  3.this 与super调用构造函数的时候不能同时出现在一个构造函数中，因为都需要放在第一个语句。


  方法的重写：子父类存在着同名的函数


  方法重写的需求：


  方法重写的需求：如果父类的功能无法满足子类的需求，那么就要进行重写


  方法重写的要素：


  1.函数名与形参列表必须一致
  2.子类的权限修饰符必须大于等父类的权限修饰符
  3.子父类的返回值类型必须小于或者等于父类的返回值类型。
  4.子类抛出的异常类型必须要小于或者等于父类抛出的异常类型。


  instanceof关键字：判断一个对象是否属于某种类型


  instanceof关键字的使用格式：


  对象  instanceof 类。
   
   instanceof的使用前提：判断的对象与类型必须存在继承或者实现关系。




*/


class Demo1 
{
public static void main(String[] args) 
{
System.out.println("Hello World!");
}
}