Java基础day9（重写，多态，final、static关键字，抽象方法，抽象类）

（重写，多态，final、static关键字，抽象方法，抽象类）

重写

重写前提：

1. 前提是子类必须继承了父类
2. 如果子类继承了父类以后，如果父类的方法满足不了我的要求，我可以在子类对父类的方法进行重写
3. 重写的规则

• 子类的方法名、返回值类型必须和父类的方法名和返回类型一致
• 子类的访问修饰符不能小于父类的修饰符
• 子类和父类方法必须同为static或非static

多态

什么是多态？就是一个对象的多种形态
使用的多态的前提必须有继承或者接口的实现

1.方法的重载和重写是一种多态
2.子类对象的多态性
必须有继承
必须对父类方法进行了重写

3.程序分为两种状态，一个是编译状态，一个是运行状态
对于多态来说，编译时他看的是左边的内容，将变量看做是person类型
运行时，看右边，真正执行的对象，也就是子类对象，执行时执行的是子类重写父类的方法

public static void main(String[] args) {
//创建人类对象
  Person per=new Person();
  per.setName("赵四");
  per.setAge(52);
  System.out.println(per);//默认都会调用tostring方法
  System.out.println("姓名："+per.getName()+",年龄："+per.getName());
  per.eat();
  per.sleep();
  
  //男人类
  Man man=new Man();
  man.eat();
  man.sleep();
  
  System.out.println("======================");
  //对象的多态性
  //就是父类的引用引起子类对象
  Person p1=new Man();//向上转型
  //虚拟方法调用：当父类的引用指向子类对象时，实际执行的是子类重写父类的方法
  p1.eat();
  //通过P1可以调用子类独有的方法吗？
  //在编译期间，程序会把p1看成person类型，而person中没有走路的方法
//  p1.wark();
  
//  int a=10;
//  short b=(short)a;
  System.out.println("=======================");
  Person p2=new WoMan();
  WoMan w1=(WoMan)p2;//向下转型
  w1.eat();
  //我就想调用子类独有的方法
  w1.shopping();
  System.out.println("===========================");
  
  //为什么？因为p1已经转成男人了，把男人转成女人程序是有问题的
//  WoMan w2=(WoMan)p1;
//  w2.eat();
  
  /*instanceof:格式：a instanceof 类A*/
  //判断a是否是类A的实例，如果是就返回true ,如果不是就是false
  if(p1 instanceof WoMan){
   WoMan w2=(WoMan)p1;
   w2.shopping();
  }
  if(p1 instanceof Man){
   Man w3=(Man) p1;
   w3.walk();
  }
}

final

final关键字代表最终、不可改变
常见的几种用法
1.修饰类
2.修饰方法
3.修饰成员变量
4.修饰局部变量

final 关键字的用法
public final class 类名{
}

修饰类，该类有啥特点？
这个类就不能被继承，就是一个最终类（太监类）
但是可以继承别的类

使用final成员变量，成员变量的值是不可改变的
1.由于成员变量放在堆里面，那么就会有默认值，如果用final修饰成员变量，那么这个成员变量将不会再有默认值
2.如果使用了final关键字，那么要直接对成员变量进行赋值

final修饰方法，这个方法就是一个最终方法，这个方法不能被重写
final修饰局部变量

public static void main(String[] args) {
//多态
//  Father fa=new Son();
//  fa.show();
  
  int num=10;
  System.out.println(num);
  num=20;
  System.out.println(num);
  
  //如果final修饰局部变量，那么这个变量的值是不能进行改变的
  final int num1=10;
  System.out.println("num1"+num1);
//  num1=20;//错误的
  
  final int num2;//正确
  num2=10;
  System.out.println(num2);
//  num2=12;
  System.out.println("==============");
  
  
  //stu:保存是地址值  引用类型
  Student stu=new Student("张三", 101);
  stu=new Student("李四",10);
  System.out.println(stu);
  
  //引用类型变量保存的是地址值
  //基本数据类型保存的变量值
  final Student stu1=new Student("王五", 18);
//  stu1=new Student();
  stu1.setStuName("王二麻子");
  System.out.println(stu1);
}

static

static:如果成员变量使用static，那么这个变量就不属于对象自己了，而是属于类本身
*

• 如果方法使用static关键字，那么这个成员方法就不属于对象自己了，而是属性类本身
• 如果没有使用static的方法，必须得先创建这个对象，然后通过【对象名.方法名】的方式进行调用
• 如果使用了static的方法，就不需要去创建对象了，而是通过【类名.方法名】的方式进行调用
• 注意：
• 静态方法中不能调用非静态的变量
• 在普通方法中可以调用静态变量吗？可以

//普通方法
 public void eat(){
  System.out.println("学生上课不能吃饭");
 }
 //静态方法
 public static void sleep(){
  System.out.println("学生上课不能睡觉");
  
 }


  Student.sleep();//静态方法可以直接通过【类名.方法名】的方式调用
  
  Student stu=new Student("张三", 12, 10001, "男");
  //普通方法的调用，必须得先创建对象
  System.out.println("===普通方法");
  stu.eat();
  System.out.println("====静态方法");
  stu.sleep();//不推荐
  System.out.println(stu);
  
  //如果在当前类中调用当前类的静态方法
  show();

 int a=10;
 static int b=20;
 public static void show(){
  //System.out.println(a);
  //错误：静态方法中不能调用非静态的变量
 }
 
 public  void show1(){
  System.out.println(b);
 }

抽象方法

定义抽象方法:public abstract void eat()；这就是一个抽象方法

• 抽象方法的特点：
• 1.只有方法的定义，没有方法体
  抽象类
• 抽象类：在class前面加上abstract
• 抽象类的特点：
• 1.抽象方法所在的类必须是抽象类
• 2.抽象类不能被实例化
• 3.如果要实现抽象类，必须创建一个子类去继承抽象类
• 4.子类继承一个抽象类，必须重写抽象类中的所有抽象方法(子类也是抽象类除外)
• 5.抽象类中可以定义普通方法
• 6.抽象类可以定义构造方法

//动物 这是一个抽象类
public abstract class Animal {
private String name;//名字
 
 //抽象方法：动物吃饭，这就是一个抽象的，因为我不知道具体是什么动物
 public abstract void eat();
 
 //睡觉方法
 public abstract void sleep();
 //普通方法
 public void show(){
  System.out.println("呵呵");
  }
  public String getName() {
  return name;
  }
  public void setName(String name) {
  this.name = name;
  }
}
//调用吃饭方法,抽象类不能被实例化，因为动物类也是一个抽象的