乐趣区

关于java:Java程序设计03面向对象编程核心2

jiezi

面向对象编程外围（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){Animal 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();}
}
退出移动版