**点赞的人都美丽

前言：

1.java中继承：就是子类继承父类的方法和成员变量和c++中继承相似；
2.抽象类：学过c语言的就知道有函数实现和函数声明；抽象类就好像函数声明写在抽象类中但这抽象类不止有函数声明还有成员变量；
3.接口：接口就是抽象类的运用提供的方法；具体详见接口和接口继承
4.主要是要对java中的修饰符要有一定了解
注意如下：缺省即默认自己要知道
interface Face1
{ double PI=3.14;等价于public static final double PI=3.14;
abstract double area( );等价于public abstract double area( );
}

1 .域隐藏

定义：子类定义与父类同名的成员变量
定义父类person子类student详细看代码注释；

class Person {
    protected String name; 
    protected int age;
    protected void show() 
    {
     System.out.println("姓名："+name+" 年龄："+age); }
}
class Student extends Person {
    private String department;
    int age = 20; //与父类age同名 (域隐藏） 
    public Student(String xm, String dep)
    {
        name = xm;
         department = dep; 
         super.age=25;
        System.out.println("子类中的成员变量age=“ +age); 
        super.show(); //只写show()亦可
            System.out.println("系别：" + department);
    }
}

2.方法覆盖

what is 覆盖（Overriding）？ ü在子类中，定义名称、参数个数与类型均与父类完全相同的方法 ü用以重写父类里同名的方法;

父类
class Person {
    protected String name; 
    protected int age;
    protected void show() 
    {
     System.out.println("姓名："+name+" 年龄："+age); }
}
子类
class Student extends Person
{
    private String department;
    int age = 20; //与父类age同名(域隐藏)
    public Student(String xm, String dep)
    {
        name = xm;
        department = dep;
        super.age = 25;
        System.out.println("子类中的成员变量age=”+ age);
        super.show();
        //只写show(亦可
        System.out.println("系别: " + department);
    }
}
class Animal
{
       void play()
    {
    System.out.println("我是动物，我会很多本领");
    }
}
//定义Animal类的子类Bird，覆盖Animal类的play( )方法，并在play( )方法中输出"我是小鸟，我能飞翔"
class Bird extends Animal {
    void play()
    {
        System.out.println("我是小鸟，我能飞翔");
    }
}
//定义Animal类的子类Fish，覆盖Animal类的play( )方法，并在play( )方法中输出"我是小鱼，我能游泳"
class Fish extends Animal {
    void play()
    {
        System.out.println("我是小鱼，我能游泳");
    }
}
class day04
{
      public static void main(String[] args)
{
       Animal s1=new Animal();
    Bird s2=new Bird();
    Fish s3=new Fish();
    s1.play();
    s2.play();
    s3.play();
}
}

3.final修饰符

◆final修饰方法
V最终方法
v功能和内部语句不能被更改，即不能被子类所覆盖
v final方法的好处:固定该方法所对应的
V默认规则:所有被private限定的私有
具体操作，防止子类误对父类关键方法
方法及所有包含在final类中的方法，
的重定义，保证程序安全性和正确性。
都被缺省地认为是final方法。
◆父类中声明为final的成员在子类中可以被继承，但不能被覆盖。
4.static与java
◆final
V final在方法之前，防止该方法被覆盖v final在类之前，表示该类不能被继承
V final在变量之前，定义一个常量
◆static
V static在变量或方法之前，表明它们属于类
class Test
{ char data;
static int share_ data; }
class Demo
{ Test a,b,c,d}

5.抽象类与抽象方法

abstract class 类名 {
成员变量；
返回值的数据类型方法名（参数表）{ …… }
abstract 返回值的数据类型方法名（参数表）;
}
抽象类中不一定包含抽象方法，可以包含普通方法。
所有抽象方法都必须存在于抽象类之中，且没有方法体。
第一步：抽象类定义
第二步：子类定义
第三步：子类对象创建定义

abstract class Shape
{
    abstract float area(); //声明一个返回单精度型的抽象方法area( )
    abstract void printArea();//声明一个没有返回值的抽象方法printArea( )
}
class Rectangle extends Shape
{
      int width;
    int length;
    public Rectangle(int newWidth,int newLength)
    {
        width=newWidth;
        length=newLength;
    }
   float area()//实现父类的抽象方法area( )，返回width*length的值
   {
       return width*length;
   }
    @java.lang.Override
    void printArea()  //实现父类的抽象方法printArea( )，在屏幕上显示矩形的面积
    {
        System.out.println("矩形的面积"+area());
    }
}
class Circle extends Shape
{
      final float PI=3.14F;
    int radius;
    public Circle(int newRadius)
    {
        radius=newRadius;   }
     float area() //实现父类的抽象方法area( )，返回PI*radius*radius的值
     {
         return PI*radius*radius;
     }
      void printArea()//实现父类的抽象方法printArea( )，在屏幕上显示圆的面积
      {
          System.out.println("圆的面积"+area());
      }
}
class day04
{
      public static void main(String[] args)
{
      Rectangle s1=new Rectangle(3,4);
    Circle s2=new Circle(2);
    s1.printArea();
    s2.printArea();
}
}

抽象类的概念：无法创建具体实例的类
抽象类的声明：使用关键字 abstract修饰类与方法
抽象类的应用:实现的步骤 w 面向抽象编程，体现“ 开闭原则;
拓展：
在这里插入图片描述

接口(implements)

interface Achievement
{
   public abstract float average();
}  //声明一个返回float型的方法average( )
class Person
{
       String name;
    int age;
    public Person(){
    }
    public Person(String newName, int newAge)
    {
        name = newName;
        age = newAge;
    }
    public void introduce( )
    {
      System.out.println("你好，我是"+name+",今年"+age+"岁"); }
}
class Student extends Person implements Achievement //继承Person类并实现Achievement接口
    {
        int chinese,math,english;
public Student(String newName, int newAge)//调用父类的构造方法Person(String newName, int newAge)
        {
            super(newName,newAge);
        }
public void setScore(int c, int m, int e)
        {
         chinese= c;
        math= m;
        english= e;
        }
public float average()
        {
            return (chinese + math+ english)/3;
        }
        }
class day04
{
    public static void main(String[ ] args)
{
      Student s1 = new Student("张三",16);
          s1.introduce();  //调用s1的introduce( )方法
    s1.setScore(80,90,80);
         System.out.println("平均分"+s1.average());//显示s1的平均分
}
}

接口继承

问题：已经定义好的接口，可以被其他接口所继承吗？
回答：ok;
接口继承的概念，规则，应用；
在这里插入图片描述

interface Face1
{
      public static final double PI=3.14;
    abstract double area( );
}
interface Face2
{
    abstract void setColor(String c); }
interface Face3 extends Face1,Face2//继承Face1和Face2接口
{
    void volume();//定义无返回值的抽象方法volume()
}
public class day04  implements Face3//实现Face3接口
        {
private double radius;
private int height;
protected String color;
public  day04(double r, int h)
        {
        radius=r;    height=h;  }
        public  double area( ) //实现area()方法，求解圆柱底面积
        {
            return  PI*radius*radius;
        }
        public void setColor(String c)//实现setColor()方法，输出颜色
        {
            System.out.println("Color:"+c);
        }
        public void volume()//实现volume()方法，求解并输出圆柱体积
        {
            System.out.println("圆柱体积"+area()*height);
        }
public static void main(String[] args)
        {
        day04 volu=new day04(3.0,2);
        volu.setColor("红色");
        volu.volume();
        }
        }