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!");
}

}