不能，重写只适用于实例方法,不能用于静态方法,而子类当中含有和父类相同签名的静态方法,我们一般称之为隐藏.

1.继承:父类和子类之间是层级结构关系，子类通过继承父类拥有父类的非private的属性和方法。提高了代码的复用性。
1）单继承：只能允许继承自一个父类；
2）子类可以扩展，即拥有自己的属性和方法；
3）子类可以重写父类的方法；
4）super关键字来实现对父类成员的访问，用来引用当前对象的父类。this关键字：指向自己的引用。
5）final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
6）子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。

2.方法的重写与重载：
1）重写：子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
2）重载：在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

3.抽象类和抽象方法：
1）抽象类：不能实例化对象，必须有子类继承才能使用。抽象类并不一定含抽象方法。
2）抽象方法：拥有抽象方法的类，一定是抽象类。抽象方法只包含一个方法名，而没有方法体。子类必须重写实现该抽象方法。

4.接口：是抽象方法的集合，接口通常以interface来声明。
1）类描述对象的属性和方法。接口则包含类要实现的“抽象”方法。
2）接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
3）接口可以支持多继承。
4）接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
5）接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
6）一个类可以实现多个接口

普通类的继承的定义与使用：

package com.example.javatest;
/**
 * Author:W
 * 动物基类继承
 */
public class Animal {
    protected   String name;

    public  Animal()
    {

    }

    public Animal(String name)
    {
        this.name = name;
    }

    //子类方法重写：吃
    public void  eat(){}
    //子类方法重写：跑
    public  void  run(){}
}

package com.example.javatest;

/**
 * Author:W
 * 狗
 */
public  class  Dog extends Animal
{
    /*==============方法重载==========*/
    public Dog()
    {

    }

    public Dog(String name)
    {
        super(name);
    }

    /*==============方法重写==========*/
    @Override
    public void eat() {
//       super.eat();
        System.out.println("狗："+name+" 在吃...");
    }

    @Override
    public void run() {
//        super.run();
        System.out.println("狗："+name+" 在跑...");
    }
}

抽象类的继承定义与使用：

package com.example.javatest;

/**
 * Author:W
 * 形状（抽象类继承）
 *
 */
public abstract class Shape {
    public  float width;
    public  float height;
    //抽象方法：没有方法体
    public  abstract  float GetArea(float width,float height);
}

package com.example.javatest;

/**
 * Author:W
 * 三角形
 */
public class Triangle extends Shape{

    @Override
    public float GetArea(float width, float height) {
        this.width = width;
        this.height = height;

        float area = width*height/2;
        System.out.println("三角形的面积："+area);
        return area;
    }
}

package com.example.javatest;

/**
 * Author:W
 * 正方形
 */
public class Rectrangle extends Shape{

    @Override
    public float GetArea(float width,float height) {
        this.width = width;
        this.height = height;

        float area = width * height;
        System.out.println("正方形的面积："+area);
        return area;
    }
}

接口的定义与使用

package com.example.javatest;

/**
 * Author:W
 * USB接口1
 */
public interface USB {
    public int X = 3;//相当于public static final int X = 3;
    public void adjust();//相当于public abstract void adjust();
    public void power();
}

package com.example.javatest;

/**
 * Author:W
 * USB接口2
 */
public interface USB2 {
    public void rechagre();
}

package com.example.javatest;

/**
 * Author:W
 * 接口实现
 */
public class  MusicUSB implements USB,USB2
{
    @Override
    public void adjust()
    {
         System.out.println("MusicUSB实现接口USB方法adjust");
    }

    @Override
    public void power()
    {
        System.out.println("MusicUSB实现接口USB方法power");
    }

    @Override
    public void rechagre() {
        System.out.println("MusicUSB实现接口USB2方法rechagre");
    }
}

测试脚本类

package com.example.javatest;//包名定义

/**
 * Author:W
 * 1.继承:父类和子类之间是层级结构关系，子类通过继承父类拥有父类的非private的属性和方法。提高了代码的复用性。
 * 1）单继承：只能允许继承自一个父类；
 * 2）子类可以扩展，即拥有自己的属性和方法；
 * 3）子类可以重写父类的方法；
 * 4）super关键字来实现对父类成员的访问，用来引用当前对象的父类。this关键字：指向自己的引用。
 * 5）final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
 * 6）子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。
 *
 * 2.方法的重写与重载：
 * 1）重写：子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
 * 2）重载：在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
 *
 * 3.抽象类和抽象方法：
 * 1）抽象类：不能实例化对象，必须有子类继承才能使用。抽象类并不一定含抽象方法。
 * 2）抽象方法：拥有抽象方法的类，一定是抽象类。抽象方法只包含一个方法名，而没有方法体。
 *
 * 4.接口：是抽象方法的集合，接口通常以interface来声明。
 * 1）类描述对象的属性和方法。接口则包含类要实现的“抽象”方法。
 * 2）接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
 * 3）接口可以支持多继承。
 * 4）接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
 * 5）接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
 * 6）一个类可以实现多个接口
 */
public class MainTest {
    public static void main(String[] args)
    {
         System.out.println("=====普通类的继承====");
         Animal dog = new Dog("阿黄");
         dog.eat();

         System.out.println("=====抽象类的继承====");
         Shape  triangle = new Triangle();
         triangle.GetArea(3.5f,5f);

         System.out.println("=====接口的实现====");
         USB  musicUSB1 = new MusicUSB();
         musicUSB1.adjust();
         musicUSB1.power();

         USB2 musicUSB2 = new MusicUSB();
         musicUSB2.rechagre();

    }
}

运行结果如下：

1. 抽象类

	关键字：abstract

类：用来描述一类具体的事物
抽象类：抽象的、模糊的、不具体的类

在Java的普通类中是不允许多继承的，原因是会出现调用
不明确的问题;

总结：父类中的功能是不能删除的，但其形式是不需要的（没有存在的意义），此时就可以将父类中功能的 具体实现 形式 给删掉;
类的具体实现：创建对象

抽象方法存在的意义是什么？

	用于定义功能，明确该类具备此功能-----规则

特点：

	1.抽象类可以有抽象方法，也可以有非抽象的方法

	2.抽象类中可以有构造器，但是不能创建对象，
	  空间需要由子类对象来开辟

2. 方法的重写

方法重载：在同一个类中，方法名相同，参数列表不同（参数位置、参数个数、参数类型），与返回值无关

方法重写：在继承或实现的关系下，方法名相同，参数列表相同，返回值类型相同，子类的修饰权限要大于或等于父类中的修饰符权限

1. 什么情况下需要重写父类中的类型呢？

1.1 子类有自己的特殊实现形式时，此时就可以重写父类中的功能
	如果没有特殊实现就不需要重写（此时重写不是必须的）

2.1 所有的子类都有自己的特殊实现形式时，父类中的功能也就没
    必要有具体的实现，就会变成抽象，那此时，其所有的子类都
    必须重写父类中全部的抽象方法

2. @Override 称为注解，此处的含义是重写，如果方法上加上了该注解，就代表该方法是从父类中重写过来的（如果此时删除了父类中的该方法，子类就会报错）

// 调用
public class Demo {
	public static void main(String[] args) {
		
	}
}

package day0202;
// 爷爷类（抽象类）
public abstract class Old {
	private String type;
	private String name;
	private String color;
	private int age;
	
	public abstract void eat();
	public abstract void sleep();
	public abstract void weight();
	
	
	
	public void ear() {
		System.out.println("圆圆的");
	}
	public void tail() {
		System.out.println("尾部是卷的");
	}
	
	
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
}

package ****;
// 父类继承爷爷类
	public class Parent1 extends Old {
		
		private String eyes;
		
		
		@Override
		public void eat() {
			super.ear();
			super.tail();
			System.out.println("吃肉，通过哺乳其他动物");
		}
		
		@Override
		public void sleep() {
			System.out.println("困了就睡觉");
		}
		
		@Override
		public void weight() {
			System.out.println("比较大");
		}
	}

当在继承关系中，子父类中有相同的方法或变量时，程序的编译执行有什么区别

	非静态的方法：执行的时候走的是子类中覆盖后的方法
	非静态的变量：执行的时候走的是子类中的变量

• 静态的方法：执行的是调用者中的方法

• 静态的属性：执行的是调用者中的方法

• 抽象方法不能与哪些关键字共存？

private：private修饰的方法只能在本类中使用，而抽象方法要求必须让子类实现，两者相互矛盾
final：final修饰的方法不能被重写，而抽象方法必须要被重写，
static：static修饰的方法可以通过类名直接调用，而抽象方法是没有方法体的