Java程序设计03——面向对象编程核心（2）

面向对象编程核心（2）

---

一.抽象类

1.概述

一个没有方法体的方法应该被定义为抽象方法，而类中如果有抽象方法，则类为抽象类。

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

2.抽象类的特点

1)抽象类和抽象方法必须用abstract修饰。

2）抽象类中不一定有抽象方法，但抽象方法一定在抽象类中。

3）抽象类不能实例化，只能通过子类实例化（类似向上转型）

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

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

public class AnimalDemo{
       public static void main(String[] args){
            Animal a = new Cat();
            a.eat();
            }
}

4)抽象类的子类要么是抽象类，要么重写抽象类中所有的方法

public abstratc class Animal{
       public abstract void eat(){
           }
           
        public abstract void sleep(){
           }   
}      

public class Cat extends Animal{
        @Override
        public void eat(){
            System.out.println("猫吃鱼");
            }
            
         public void sleep(){
             System.out.println("猫睡觉");
             }
}

或：

public class abstract Cat extends Animal{
      
}

5)抽象类的构造方法和成员方法
有构造方法，但不能实例化，用于子类访问父类数据的初始化。而成员方法有抽象方法，主要用于规定子类方法必须完成的动作，也有非抽象方法，用于提高代码复用性。

二.接口

1.概述

接口是一种公共的规范标准，只要符合标准，大家可以通用。Java的接口更多体现在对行为的抽象。

2.接口的特点

1）接口用关键字interface修饰

2）类实现接口用implements表示,同时接口中的方法都为抽象方法(void show() = public abstract void show())

public class 类名 implements 接口名 {}

3)接口直接不能实现化，方法与多态相似

public interface Eat{
       public abstract void eat()
}      

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

public class EatDemo{
       public static void main(String[] args){
            Eat a = new Cat();
            a.eat();
            }
}

4）接口的实现类要么是抽象类，要么重写接口中所有的方法

public interface Eat{
       public abstract void eat(){
           }
           
        public abstract void sleep(){
           }   
}      

public class Cat implements Eat{
        @Override
        public void eat(){
            System.out.println("猫吃鱼");
            }
            
         public void sleep(){
             System.out.println("猫睡觉");
             }
}

或：

public class abstract Cat implements Eat{
      
}

3.接口的成员变量和构造方法

成员变量只能为常量（默认修饰符：public static final)，没有构造方法。

4.类和接口的关系

public class InterImpl extends Object implements Inter1,Inter2,Inter3{
}

public interface Inter3 extends Inter1,Inter2{
}

5.抽象类和接口的区别

public interface Alarm{
       //接口中默认为public abstract void alarm()
       void alarm();
}

public abstract class door{
        public abstract void open();
        public abstract void close();
}

public class AlarmDoor extends door implements Alarm{
        public void alarm(){
        //...
        }
        
        public void close(){
        //...
        }
        
        public void open(){
        //...
        }
}

在开发中，抽象类更多是对事物的抽象，接口是对行为的抽象。

6.抽象类和接口作为形参和返回值

1）抽象类：

public interface Jumping{
        void jump(){
           }
}      

public class Cat implements Jumping{
        @Override
        public void jump(){
            System.out.println("猫跳高");
            }
}

public class JumpingOperator{
        //方法的形参是接口名，其实需要的是该接口的实现类对象
        public void useJumping(Jumping j){
              j.jump();
                  }
                  
         //方法的返回值是接口名，其实返回的是该接口的实现类对象
         public Jumping getJumping(){
              Jumping j = new Cat();
              return j;
}

public class JumpingDemo{
       public static void main(String[] args){
            JumpingOperator jo = new JumpingOperator();
            Jumping j = new Cat();
            //JumpingOperator中相当于Jumping jo = new Cat();
            jo.useJumping(j);
            
            //相当于Jumping j2 = new Cat()
           Jumping j2 = ao.getJumping();
            a2.jump();
            }
}

2）接口：

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

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

public class AnimalOperator{
        //方法的形参是抽象类名，其实需要的是该抽象类的子类对象
        public class useAnimal(Animal a){
              a.eat();
                  }
                  
         //方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
         public Animal getAnimal(){
              Animal a = new Cat();
              return a;              
}

public class AnimalDemo{
       public static void main(String[] args){
            AnimalOperator ao = new AnimalOperator();
            Animal a = new Cat();
            //AnimalOperator中相当于Animal a = new Cat();
            ao.useAnimal(a);
            
            //相当于Animal a2 = new Cat()
            Animal a2 = ao.getAnimal();
            a2.eat();
            }
}

三.内部类

1.概述

在一个类中定义一个类，例如在类A中定义类B，B就是内部类

public class Outer{
       public class Inner{
            }
}

2.内部类的访问特点（仅限于内部类和外部类，不涉及外部类以外的类）

1）内部类可以直接访问外部类的成员，包括私有成员

2）外部类要访问内部类的成员，必须创建对象

public class Outer{

       private int num = 19;
       public class Inner{
               public void show(){
                     System.out.println(num);
            }
        }
        
        public void method(){
             Inner i = new Inner();
             i.show();
            }
}

3)外部类以外的类想访问内部类的对象的对象创建方式

public class Outer{

       private int num = 19;
       public class Inner{
               public void show(){
                     System.out.println(num);
            }
        }
        
        public void method(){
             Inner i = new Inner();
             i.show();
            }
}

public class InnerDemo{
         public static void main(String[] args){
               //创建内部类对象
               Outer.Inner oi = new Outer().new Innre();
               oi.show();
               }
}

3.局部内部类

局部内部类在方法里定义的类，外界无法直接使用，需要在方法内部创建对象使用，该类可以直接访问外部类的成员，也可以访问方法内的局部变量

public class Outer{
       private int num = 10;
       
       public void method(){
             class Inner{
                  public void show(){
                        System.out.println(num);
                        }
                   }
       
       Inner i = new Inner();
       i.show();
    }
}
      
public class OuterDemo{
        public static void main(String[] args){
              Outer o = new Outer();
              o.method();
            }
}

4.匿名内部类

前提：存在一个类或接口，然后在方法中创建

格式：

new 类名或者接口名（）{
      重写方法；
}

new Inter(){
      public void show(){
          }
}

本质是一个继承了该类或者实现了该接口的子类匿名对象

具体实现：

public class Outer{
       public void method() {
              //new Inter仅仅是一个对象，在后面加上.show()才是方法的调用
              Inter i = new Inter() {
                   @Override
                   public void show() {
                       System.out.println("匿名内部类");
                       }
             }
             
             i.show();
       }
}

public interface Inter{
      void show();
}

public class OuterDemo{
        public static void main(String[] args){
              Outer o = new Outer();
              o.method();
            }
}              

Tips：

1）没有构造方法

2）不能用private,public,static,final等词修饰

3）只能使用一次

四.Object类

1.是所有类的父类

class Anything{
    ....
}
等价于
class Anything extends Object{
    ....
}

2.toString()方法

public String toString()
{
    return getClass().getName() + "@" + Integer.toHexString(hashCOde());
}

一般使用时会重写，会自动生成（https://jingyan.baidu.com/art...

3.equals（）方法

Object中的equals方法是直接判断this和obj本身的值是否相等，即用来判断调用equals的对象和形参obj所引用的对象是否是同一对象.

public boolean equals(Object obj){
    return (this == obj)
}


System.out.println(b1.equals(b2));
System.out.println(b1.equals(b3));
System.out.println(b1.equals("hello"));

输出结果:
true
false
false