Java初学笔记--面向对象3

一、抽象方法和抽象内容
抽象方法：
--包含抽象方法的类必须是抽象类
--由abstract修饰
只有方法的定义，没有具体的实现（连{}都没有）
抽象类：
--包含抽象方法的类必须是抽象类
--抽象类不能被实例化（new对象）但是可以创建数组
--抽象类不能单独存在
--抽象类是需要被继承的，派生类直接继承会报错，常规的两种处理办法：
1.也声明为抽象类----------一般很少这么做
2.必须重写所有抽象方法---变不完整为完整（常见做法）
--抽象类的意义：
1.封装共有的属性和行为，实现代码复用
2.可以包含抽象方法，为所有派生类统一入口（名字统一）强制必须重写
二、接口：
是一种引用类型
由interface定义
只能包含抽象方法(常量、默认方法、静态方法、私有方法)默认接口内的所有方法都是抽象的
 

package ooday03;

/**
* 接口
 */
public interface Inter {
    abstract void show();
    void test();//接口中的方法默认都是抽象的，前面默认有abstract
    
    //void say(){}//编译错误，抽象方法不能有方法体
}

--不能被实例化

    public class InterfaceDemo {
         public static void main(String[] args) {
             //Inter o = new Inter(); //编译错误，接口不能被实例化
         }
     }

--接口是需要被实现的 实现类  必须重写接口中的所有抽象方法
 -注意 重写接口中的抽象方法时 必须加public

    interface Inter {
           abstract void show();
           void test(); //接口中的方法默认都是抽象的，前面默认有abstract
           //void say(){} //编译错误，抽象方法不能有方法体
       }
       class InterImpl implements Inter {
           public void show(){ //重写接口中的抽象方法时，必须加public
           }
           public void test(){
           }
       }

--一个类可以实现多个接口。若又继承又实现，应该先继承后实现

//演示接口的多实现
     interface Inter1{
         void show();
     }
     interface Inter2{
         void test();
     }
     abstract class Aoo{
         abstract void say();
     }
     class Boo extends Aoo implements Inter1,Inter2{
         public void show(){}
         public void test(){}
         void say(){}
     }

--接口可以继承接口

三、引用类型数组：
数组元素为引用类型的数组，即为引用类型数组
<代码段>
与基本类型数组只有两点区别：
1.给引用类型数组的元素赋值是，需要new个对象
2.访问引用类型数组的元素的属性/行为时，需要打点访问

    public class RefArrayDemo {
         public static void main(String[] args) {
             Dog[] dogs = new Dog[3];
             dogs[0] = new Dog("小黑",2,"黑");
             dogs[1] = new Dog("小白",1,"白");
             dogs[2] = new Dog("小灰",3,"灰");
             System.out.println(dogs[0].name); //输出第1只狗狗的名字
             dogs[1].age = 4; //修改第2只狗狗的年龄为4岁
             dogs[2].swim(); //第3只狗狗在游泳
             for(int i=0;i<dogs.length;i++){ //遍历dogs数组
                 System.out.println(dogs[i].name); //输出每只狗狗的名字
                 dogs[i].eat(); //每只狗狗吃饭
             }
     
             Chick[] chicks = new Chick[2];
             chicks[0] = new Chick("小花",1,"花");
             chicks[1] = new Chick("大花",2,"白");
             for(int i=0;i<chicks.length;i++){ //遍历chicks数组
                 System.out.println(chicks[i].name);
                 chicks[i].layEggs();
             }
     
             Fish[] fish = new Fish[4];
             fish[0] = new Fish("小金",2,"金");
             fish[1] = new Fish("大金",4,"白");
             fish[2] = new Fish("小绿",1,"绿");
             fish[3] = new Fish("小红",3,"红");
             for(int i=0;i<fish.length;i++){ //遍历fish数组
                 System.out.println(fish[i].color);
                 fish[i].drink();
             }
     
             /*
             //声明Dog型数组dogs，包含3个元素，每个元素都是Dog类型，默认值为null
             Dog[] dogs = new Dog[3];
             //声明Chick型数组chicks，包含3个元素，每个元素都是Chick类型，默认值为null
             Chick[] chicks = new Chick[3];
             //声明Fish型数组fish，包含2个元素，每个元素都是Fish类型，默认值为null
             Fish[] fish = new Fish[2];
              */

补充：

1.设计规则：
将派生类所共有的属性和行为，抽到超类中-----抽共性
若将派生类的行为/代码都一样，设计为普通方法
若派生类的行为/代码不一样
2.接口间继承
类和类-------------------extends
接口和接口--------------extends
接口和类-----------------implement

3.null:表示空没有指向任何对象
若引用的值为null，则该引用不能再进行任何点操作了，若操作则发生NullPointerException空指针异常