Java从头开始--封装、继承和多态

面向对象的三大特征

1.面向对象语言的三大特征
封装
继承
多态

封装

封装的概念

将类中的某些信息（成员变量，方法）隐藏起来，不让外部的程序直接访问，可通过专门的方法来实现对隐藏信息的操作和访问。

封装的好处

封装的具体表现

属性使用private权限
方法使用public权限

例如：

  public class Demo{
		private String name;         
		public String getName (){ 
			return name;
		}    
		public void setName(String name){                                             this.name = name;
              	}
         } 

this关键字

this关键字代表自身类的对象

使用this关键字引用成员变量

使用this关键字引用成员方法

注意this关键字必须放在非静态的方法里面

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式类引用成员变量名，常常用来区分同名的成员变量和局部变量

例如：

public class Demo{
	private int a;		
	public Demo(int a){
	    this.a = a;
	}		
	public int getA(){
		return a;
	}		
	public void setA(int a){
		this.a = a;
	}
}

实例1：

package com.ff.javaoop.day4;
/*
面向对象的三大特征：封装，继承，多态
 */
/*
封装：将类中的某些信息（成员变量，方法）隐藏起来，不让外部的程序直接访问，可通过专门的方法来实现对隐藏信息的操作和访问。
 */
public class Dog {
    private String name;
    private int age;
    //用构造方法实现对私有方法的调用

    /*public Dog(String name,int age){
    if(name.length()<5){
        this.name = name ;
        }
        this.age = age;
    }*/

    //为私有的属性提供专门的方法访问，可以实现控制
    // this 表示的是当前正在访问的对象，this关键字必须放在非静态的方法中
    public void setName(String name) {
        if (name.length() <= 7) {
            this.name = name;
            this.eat();//在本类中访问私有权限的方法
        }
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
//私有权限的方法
    private void eat() {

    }
}

package com.ff.javaoop.day4;

public class DogTest {
    public static void main(String[] args) {
        /*Dog dog = new Dog("dkjf",20);
    	Dog dog1 = new Dog("wangcai",23);
    	*/

        Dog dog = new Dog();
        dog.setName("王二狗");
        dog.setAge(20);
        System.out.println(dog.getAge());
        System.out.println(dog.getName());
    }
}

运行结果：

继承

人类都有姓名，年龄等属性和方法

学生类可以继承人类，但他们有自己特有的属性和方法如学号等

工人类可以继承人类，但他们有自己特有的属性和方法如工号等

小学生类、中学生类和大学生类都可以继承学生类

继承：继承是面向对象语言的一种设计思想，可以提高代码的可重用性（子类可以使用父类），代码的可扩展性（子类可以有自己的功能）

什么样的关系可以继承？

学生属于人

工人属于人

符合is-a关系的设计，使用继承

将子类工有的属性和行为放到父类中

继承的形式：

[访问权限修饰符] [修饰符] 子类名 extends 父类名{子类体}

例如：

public class Animal{
	public void eat(){
        
    }
}

public class Dog  extends Animal{
	public void play(){
        
    } 
}

//子类对象可以直接调用父类的方法，强调复用性
 Dog  dog = new Dog ();
     dog.eat();

继承的传递性：

C类从B类继承,B类又从A类继承，那么C类就具有B类和A类的所有非私有属性和非私有方法。

当一个没有继承任何一个类时,jvm会默认让类继承Object类，Object是 java为所有类提供的基类。

实例2.1：

package com.ff.javaoop.day4;

public class Animal {
    private String name ;
    private int age;

    public void eat(String name){
        System.out.println(name+"开饭了");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.ff.javaoop.day4;
/*
Cat 类继承Animal
Cat是Animal的子类（派生类）
extends关键字
java中一个类只能直接继承一个类
 */
public class Cat extends Animal {
private String specie;

public  void barking(){
    System.out.println("喵喵叫");
}

    public String getSpecie() {
        return specie;
    }

    public void setSpecie(String specie) {
        this.specie = specie;
    }
}

package com.ff.javaoop.day4;
/*
Pig 类继承Animal
Pig是Animal的子类（派生类）
extends关键字
java中一个类只能直接继承一个类
 */
public class Pig extends Animal{
    private String specie;
    public  void barking(){
        System.out.println("哼哼");
    }

    public String getSpecie() {
        return specie;
    }

    public void setSpecie(String specie) {
        this.specie = specie;
    }
}

package com.ff.javaoop.day4;

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat("小咪");//继承父类的方法
        cat.setAge(2);//继承父类的方法
        cat.setName("小咪");//继承父类的方法
        cat.barking();//小猫自己的属性
        cat.setSpecie("折耳猫");//小猫自己的属性

        Pig pig = new Pig();
        pig.eat("猪猪");//继承父类的方法
        pig.setAge(3);//继承父类的方法
        pig.setName("猪猪");//继承父类的方法
        pig.barking();//猪自己的属性
        pig.setSpecie("非洲野猪");//猪自己的属性

        System.out.println(pig.getName()+"今年"+pig.getAge()+"岁了");
        System.out.println(cat.getName()+"今年"+cat.getAge()+"岁了");
        System.out.println(pig.getSpecie());
        System.out.println(cat.getSpecie());
    }
}

运行结果：

实例2.2：

package com.ff.javaoop.day4;

public class ZhuBaJie {
    public void fly(){
        System.out.println("猪八戒会飞");
    }
}

package com.ff.javaoop.day4;

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat("小咪");//继承父类的方法
        cat.setAge(2);//继承父类的方法
        cat.setName("小咪");//继承父类的方法
        cat.barking();//小猫自己的属性
        cat.setSpecie("折耳猫");//小猫自己的属性

        Pig pig = new Pig();
        pig.eat("猪猪");//继承父类的方法
        pig.setAge(3);//继承父类的方法
        pig.setName("猪猪");//继承父类的方法
        pig.barking();//猪自己的属性
        pig.setSpecie("非洲野猪");//猪自己的属性

        System.out.println(pig.getName()+"今年"+pig.getAge()+"岁了");
        System.out.println(cat.getName()+"今年"+cat.getAge()+"岁了");
        System.out.println(pig.getSpecie());
        System.out.println(cat.getSpecie());
        cat.hashCode();//调用Object类中的方法，Cat extends Animal，Animal extends Object
         ZhuBaJie zhubajie = new ZhuBaJie();
         zhubajie.fly();
    }
}

运行结果：

继承中的构造方法

子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法。
可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法。
如果用super,必须写在构造方法的第一句。
如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。
原因:子类创建后需要调用父类的方法,所以在创建子类对象是父类也需要同时被创建。

super关键字

super关键字代表父类的引用，在程序中主要的用途：
在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行。
用“super.成员变量名”来引用父类成员变量。
用“super.方法名（参数列表）”的方式访问父类的方法。
与this的区别，this通常指代当前对象，super通常指代父类。

实例3：

package com.ff.javaoop.day4;
/*
父类（基类）
把动物相关的一些共同的属性，行为定义在Animal类
 */
/*
当一个类没有显示的继承一个类，那么这个类默认继承Object
Object是java中所有类的父类（基类）超类
 */

//public class Animal {
public class Animal extends Object {
    private String name;
    private int age;

    public Animal() {
        super();
        System.out.println("在Animal中定义一个无参的构造方法");
    }

    public Animal(String name) {
        this.name = name;
        System.out.println("在Animal中定义一个有参的构造方法");
    }

    public void eat(String name) {
        System.out.println(name + "开饭了");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.ff.javaoop.day4;
/*
Pig 类继承Animal
Pig是Animal的子类（派生类）
extends关键字
java中一个类只能直接继承一个类
 */
public class Pig extends Animal{
    private String specie;

    public Pig() {
        //super();
        super("哈哈");
        System.out.println("在Pig中定义一个无参的构造方法");
        //super.eat("哈哈");
    }

    public  void barking(){
        System.out.println("哼哼");
    }

    public String getSpecie() {
        return specie;
    }

    public void setSpecie(String specie) {
        this.specie = specie;
    }
}

package com.ff.javaoop.day4;
/*
在调用子类构造方法时会先调用父类的构造方法
 */
public class ZhuBaJie extends Pig {
    public ZhuBaJie() {
        //super();构造方法的第一行默认使用super(),调用父类的无参构造方法
       super();//如果要显示的调用，必须放在构造方法的第一行，先去保证父类构造方法调用
        System.out.println("在ZhuBaJie中定义一个无参的构造方法");
    }

    public void fly(){
        System.out.println("猪八戒会飞");
    }
}

package com.ff.javaoop.day4;

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat("小咪");//继承父类的方法
        cat.setAge(2);//继承父类的方法
        cat.setName("小咪");//继承父类的方法
        cat.barking();//小猫自己的属性
        cat.setSpecie("折耳猫");//小猫自己的属性

        Pig pig = new Pig();
        pig.eat("猪猪");//继承父类的方法
        pig.setAge(3);//继承父类的方法
        pig.setName("猪猪");//继承父类的方法
        pig.barking();//猪自己的属性
        pig.setSpecie("非洲野猪");//猪自己的属性

        System.out.println(pig.getName()+"今年"+pig.getAge()+"岁了");
        System.out.println(cat.getName()+"今年"+cat.getAge()+"岁了");
        System.out.println(pig.getSpecie());
        System.out.println(cat.getSpecie());
        cat.hashCode();//调用Object类中的方法，Cat extends Animal，Animal extends Object
         ZhuBaJie zhubajie = new ZhuBaJie();
         zhubajie.fly();
    }
}

package com.ff.javaoop.day4;
/*
继承中的构造方法
在创建一个子类对象时同时也会创建父类对象
 */
public class Test1 {
    public static void main(String[] args) {
        ZhuBaJie zhubajie = new ZhuBaJie();
        zhubajie.eat("猪八戒");
    }
}

运行结果：

方法的重写（OverRide）

在子类中可以根据需要对从基类中继承来的方法进行重写。
方法重写规则：
1.方法名相同、参数列表相同；
2.返回值类型相同；
3.访问权限等于或大于父类权限;
注意：构造方法不能重写
应用场景：当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)

package com.ff.javaoop.day4;
/*
在调用子类构造方法是会先调用父类的构造方法
 */
public class ZhuBaJie extends Pig {
    public ZhuBaJie() {
        //super();构造方法的第一行默认使用super(),调用父类的无参构造方法
       super();//如果要显示的调用，必须放在构造方法的第一行，先去保证父类构造方法调用
        System.out.println("在ZhuBaJie中定义一个无参的构造方法");
    }
/*
父类中的实现方式不能满足子类时使用方法的重写
方法的重写：当子类中的实现步骤与父类中的实现不同时可以在子类中将父类的方法重写（覆盖或复写）
重写要求：
子类方法的结构（返回值，参数）与父类相同
子类重写后的访问权限必须大于等于父类方法的访问权限

this表示当前的对象
super表示当前类的父类对象，在子类中可以通过super来调用父类成员
@Override 注解 可理解为标签
表示此方法是从父类中调用过来的
 */
    @Override
    public void eat(String name) {
        super.eat(name);
        System.out.println("猪八戒坐着吃");
        super.eat("猪八戒");//调用父类成员
    }

    public void fly(){
        System.out.println("猪八戒会飞");
        super.eat("猪猪");
    }
}

运行结果：

关联关系与依赖关系

关联关系（has-a）：对象和对象之间的连接。

在Java中，关联关系的代码表现形式为一个类做为另一个类的属性类型存在。即“有”的关系：”has-a”。

关联关系分为单向关联和双向关联。
单向关联： A类关联B类。
双向关联：A类关联B类,B类关联A类。

关联关系的多重性：
一对一关联：一个学生，只能在一个班级里学习。

一对多关联：一个学生，可以参加多个班级学习。
解决一对多的关联的方案：1.集合 2. 数组（list）

依赖关系(use-a) 指一个类A使用到了另一个类B
依赖关系的特性： 这种关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。

依赖具体表现
1.在代码层面，依赖关系表现为类B作为参数被类A在某个method
2.方法中使用
例如：

public  class Person {
       public void travel(Bus bus){
           
       }
   }

实例：

package com.ff.javaoop.day4;

public class Number {
    private String Number;

    public String getNumber() {
        return Number;
    }

    public void setNumber(String number) {
        Number = number;
    }
}

package com.ff.javaoop.day4;

//请写Person类，有属性姓名和年龄；请写出其构造方法，及Setter，Gestter方法.
public class Person {
    private String name;
    private int age;
    //关联关系，什么中有什么（属性中）
    private Number number;//一对一关联，单向关联
    private Number [] numbers;//一对多关联，单向关联

    //依赖关系，Person类中某个方法使用到了另一个类
    public void feedAnimal (Dog dog){
        dog.getAge();
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.setName("王二狗");
        person.setAge(21);
        System.out.println("此人的姓名为：" + person.getName());
        System.out.println("此人的年龄为：" + person.getAge());
    }
}

抽象类

使用abstract定义抽象类，一般语法:

[访问权限] abstract class 类名 {
		成员列表
	}

package com.ff.javaoop.day4.abstractDemo;
/*
被abstract修饰的类就是抽象类
抽象方法中不一定有抽象类
有抽象方法那么这个类一定是抽象类
 */
public abstract class Animal {
    /*
    在顶层的类中方法的实现与子类大多不相同，那么在顶层类中就可以将方法声明为抽象的方法
    被abstract修饰，没有方法体
    只作为方法的定义
     */
    String name;

    public Animal() {
        System.out.println("Animal");
    }
    public abstract  void sleep();
    public abstract void eat();
    public abstract void dance();
     public void play(){
         System.out.println("Animal play");
     }

}

package com.ff.javaoop.day4.abstractDemo;
/*
抽象类就是作为定义，让其他类继承
一个类继承抽象类：
要么将子类声明为抽象类，要么重写抽象类中所有的构造方法
 */
public abstract class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void play() {
        System.out.println("打豆豆");
    }

    @Override
    public void sleep() {
        System.out.println("眯眼睡");
    }
}

package com.ff.javaoop.day4.abstractDemo;

public class Cat extends Animal {
    @Override
    public void sleep() {
        System.out.println("蜷起来睡");
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    /*@Override
    public void play() {
        System.out.println("玩线团");
    }*/

    @Override
    public void dance() {
        System.out.println("空中翻转");
    }
}

package com.ff.javaoop.day4.abstractDemo;

public class TestAnimal {
    public static void main(String[] args) {
       Cat cat  = new Cat();
        cat.dance();
        cat.eat();
        cat.play();


    }
}

多态

多态：

同一事物在不同时刻的不同状态。

多态存在的三个必要条件
1.要有继承（包括接口的实现）(前提条件)
2.要有重写(前提条件)
3.父类引用指向子类对象

实例4：

package com.ff.javaoop.day4.abstractDemo;

public class Pig extends Animal{
   @Override
   public void sleep() {

   }

   @Override
   public void eat() {
      System.out.println("佩奇喜欢吃薯条");
   }

   @Override
   public void play() {

   }

   @Override
   public void dance() {

   }
}

package com.ff.javaoop.day4.abstractDemo;

public class TestAnimal {
    public static void main(String[] args) {
      /* Cat cat  = new Cat();
        cat.dance();
        cat.eat();
        cat.play();*/
      Cat cat = new Cat();
      Pig pig = new Pig();
     TestAnimal testAnimal = new TestAnimal();
     testAnimal.feedCat(cat);
     testAnimal.feedPig(pig);

    }
    public void feedCat(Cat cat){
        cat.eat();
    }
    public void feedPig(Pig pig){
        pig.eat();
    }
}

运行结果：

当有很多的子类想要调用同一种方法时需要重复写多次，代码冗余太大，需要改进。因此引入多态。

实例5：

package com.ff.javaoop.day4.abstractDemo;

public class TestAnimal1 {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.dance();//编译看左边，运行期间看右边
        Animal pig = new Pig();
        TestAnimal1 testAnimal1 = new TestAnimal1();
        testAnimal1.feedAnimal(cat);
        testAnimal1.feedAnimal(pig);

    }

    public void feedAnimal(Animal animal){
        animal.eat();
    }
}

多态转型：

基本数据类型转换：数值与数值转换

​ 默认转换 小–>大

​ 强制类型转换 大–>小

引用类型与引用类型转换

前提: 继承关系

默认转换 ：向上转型

强制转化：向下转型

1.新建一个名为Animal的类：

package com.ff.javaoop.day5duotai;

public abstract class Animal {
    int num = 10;

    abstract void eat();
    abstract void sleep();

    public static void testStatic() {
        System.out.println("静态");
    }

    public void test() {
        System.out.println("Animal test");
    }
}

2.新建一个名称为Cat的类

package com.ff.javaoop.day5duotai;

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫睡觉");
    }

    public void dance() {
        System.out.println("猫跳舞");
    }
}

3.新建一个名称为Dog的类

package com.ff.javaoop.day5duotai;

    public  class Dog  extends Animal {

        int num = 5;

        @Override
        public void eat() {
            System.out.println("狗吃肉");
        }

        @Override
        public void sleep() {
            System.out.println("狗睡觉");
        }

        public static  void testStatic(){
            System.out.println("静态");
        }

        public void play(){
            System.out.println("狗拉雪橇");
        }
    }

4.建立测试类test，分别验证成员方法，静态方法和成员变量在多态方式下的调用方式。

package com.ff.javaoop.day5duotai;

public class Test {
    public static void main(String[] args) {
          /*Dog dog = new Dog();
              dog.eat();

          Cat cat = new Cat();
              cat.eat();*/

         /*
           成员方法，多态方式调用，编译期间看左边类型,运行期间看右边。
           静态方法，多态方式调用，编译期间和运行期间都看左边
           成员变量，多态方式调用，编译期间和运行期间都看左边
         */
     
        Animal animal = new Dog();
        animal.eat();
        animal.testStatic();
        System.out.println(animal.num); 
    }
}

运行结果：

5.建立测试类test1，多态的应用。

package com.ff.javaoop.day5duotai;

public class Test1 {

    public static void main(String[] args) {

        Dog dog = new Dog();
        Cat cat = new Cat();
        Test1 t1 = new Test1();

        t1.feedAnimal(dog);
        t1.feedAnimal(cat);
    }

    //多态应用:同一种事务,在不同时刻表现不同的状态
    public void feedAnimal(Animal animal){
        animal.eat();
    }
}

6.在test1中验证向上转型

package com.ff.javaoop.day5duotai;

public class Test2 {
    public static void main(String[] args) {
        /*
        向上转型
        优点：使得父类可以表示所有子类
        缺点：子类只可以访问父类中的方法，但访问不到子类自己特有的方法
         */

        Animal dog = new Dog();
        Animal cat = new Cat();
        Test2 test2 = new Test2();

        test2.feedAnimal(dog);
        test2.feedAnimal(cat);
    }

        public void feedAnimal(Animal animal){
            animal.eat();
           // animal.play();向上转型为父类类型不能访问子类中特有的方法
    }
}

7.在test1中验证向下转型，相当于强制类型转换。可以访问子类中特有的方法。但当有多个子类调用时运行会有错误。如下所示。

package com.ff.javaoop.day5duotai;

public class Test2 {
    public static void main(String[] args) {
        /*
        向上转型
        优点：使得父类可以表示所有子类
        缺点：子类只可以访问父类中的方法，但访问不到子类自己特有的方法
         */

        Animal dog = new Dog();
        Animal cat = new Cat();
        Test2 test2 = new Test2();

        test2.feedAnimal(dog);
        test2.feedAnimal(cat);
    }

        public void feedAnimal(Animal animal){
            animal.eat();
           // animal.play();向上转型为父类类型，不能访问子类中特有的方法
            /* 向下转型：Dog dog = (Dog)animal;相当于强制类型转化
            优点：可以实现子类中特有方法的访问，但当有多个子类同时访问时可能会出现问题
            缺点：运行有错，用if 语句加instanceof改正
            animal instanceof Dog在运行时检测判断animal中实际包含是否含有指定的类型
            */
            Dog dog = (Dog) animal;
            dog.play();
    }
}

运行结果：

8.向下类型转化改正实例：用if 语句加instanceof改正

package com.ff.javaoop.day5duotai;

public class Test2 {
    public static void main(String[] args) {
        /*
        向上转型
        优点：使得父类可以表示所有子类
        缺点：子类只可以访问父类中的方法，但访问不到子类自己特有的方法
         */

        Animal dog = new Dog();
        Animal cat = new Cat();
        Test2 test2 = new Test2();

        test2.feedAnimal(dog);
        test2.feedAnimal(cat);
    }

        public void feedAnimal(Animal animal){
            animal.eat();
           // animal.play();向上转型为父类类型不能访问子类中特有的方法
            /* 向下转型：Dog dog = (Dog)animal;相当于强制类型转化
            优点：可以实现子类中特有方法的访问，但当有多个子类同时访问时可能会出现问题
            运行有错，用if 语句加instanceof改正
            animal instanceof Dog在运行时检测判断animal中实际包含是否含有指定的类型
            */
            if(animal instanceof Dog){
                Dog dog = (Dog)animal;
                dog.play();
            }
            if(animal instanceof Cat){
                Cat cat= (Cat) animal;
                cat.dance();
            }
    }
}

运行结果：

接口：

抽象类：包含抽象方法和非抽象方法

接口可以理解为一个纯粹的抽象类。在接口中定义抽象的方法。

作为上层的设计需要设计具体的功能。

接口的定义用关键字interface，接口的实现用implements。

一个接口可以继承多个接口。

一个类可以实现多个接口。

一个类可以直接继承一个类。

实例：

1.依次定义三个接口，如InterFaceA、InterFaceB和 InterFaceC

package com.ff.javaoop.day5InterFace;

public interface InterFaceA {
    void testA();
}

package com.ff.javaoop.day5InterFace;

public interface InterFaceB {
    void testB();
}

package com.ff.javaoop.day5InterFace;

public interface InterFaceC {
    void testC();
}

2.定义一个名为Animal的接口，使之继承接口InterFaceA和InterFaceB ，从而验证一个接口可以继承多个接口。

package com.ff.javaoop.day5InterFace;
    /*
    interface是定义接口的关键字
    一个接口可以继承多个接口，如接口Animal继承了InterFaceA和InterFaceB
     */
public interface Animal extends InterFaceA,InterFaceB {
    /*
    在接口中的成员变量是常量，必须得符初值
    如int NUM= 2;前面默认有public static final修饰
     */
    int NUM = 2;

	//在jdk8以后接口中声明的方法默认被public abstract修饰
    void eat();
    void sleep();
    void play();
    //jdk8以后加入静态方法和默认方法
    public static void dance(){
        System.out.println("会跳舞");
    }

    //默认方法,子类可以重写也可以不重写,或者通过子类调用
    public default void test(){

    }
}

3.定义第一个名称为Dog的类，使之继承Object类，实现接口Animal,InterFaceA和InterFaceB。从而验证一个类可以直接继承一个类并且一个类可以实现多个接口。

package com.ff.javaoop.day5InterFace;
    /*
    用接口实现继承关系时候必须使用implement
    在类中要么实现父类的全部方法，要么直接写成抽象类
     */
    /*
    一个类可以实现多个接口，如Dog类实现了接口Animal,InterFaceA和InterFaceB
    一个类可以直接继承一个类，如Dog类可继承Object类
     */
public class Dog extends Object implements Animal,InterFaceA,InterFaceB{

    @Override
    public void eat() {
        System.out.println("王二狗吃");
    }

    @Override
    public void sleep() {
        System.out.println("王二狗睡");
    }

    @Override
    public void play() {
        System.out.println("王二狗玩");
    }

    @Override
    public void testA() {

    }

    @Override
    public void testB() {

    }

}

4.编写一个测试类

package com.ff.javaoop.day5InterFace;

public class Test {
    public static void main(String[] args) {
        System.out.println(Animal.NUM);
       //Dog dog = new Dog();
        Animal dog = new Dog();
       dog.eat();
       dog.play();
       dog.sleep();
       Animal.dance();
    }
}

运行结果：

final

final修饰类，属性，方法和方法参数。

final 修饰的类不能被子类继承。

final修饰的变量为常量，值不可以变。

final修饰的方法子类不可以重写。

被final修饰的方法的参数不能改。

package com.ff.javaoop.day6;

public  final class FinalDemo {
    /*final 修饰的变量
    1.final int num = 56;直接初始化常量建议有static修饰，在内存中只有一份
    2.先定义再写出他的构造方法
   final int count;
   public FinalDemo(int count) {
        this.count = count;
    }
    在创建的每一个对象中包含一个常量，必须在构造方法中赋值*/
    /*
     final修饰的变量为常量，值不可以变
     */
    //final int num = 56;
    static  final int num = 56;
    final int count ;
    public FinalDemo(int a) {
       count = a;
    }

    public final void eat(){
        System.out.println("eatting...");
    }
    /*
    被final修饰的方法的参数不能改
     */
    public void test (final int a){
       // num = 5;
        System.out.println("testing....");
        //a = 5;
    }

    public static void main(String[] args) {
        FinalDemo f1 = new FinalDemo(10);
        FinalDemo f2 = new FinalDemo(5);
    }
}

package com.ff.javaoop.day6;
//final 修饰的类不能被子类继承
/*public class Zi extends  FinalDemo {

}*/
//final修饰的方法子类不可以重写
/*public class Zi extends  FinalDemo{
    public void eat(){

    }
}*/