专业实习02

2017-6-20 专业实习第二天

1.关于面向对象（封装 继承 多态 抽象类 接口）

http://www.cnblogs.com/forwardpower/archive/2010/05/01/1725787.html

• 封装
  把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

访问修饰符：

修饰符	解释
Private	只有类本身能存取
Protected	类和派生类可以存取
Internal	只有同一个项目中的类可以存取
Public	完全存取

• 继承

  使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

  一个子类可以继承多个基类（父类）。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

  继承概念的实现方式有三类：实现继承、接口继承 和可视继承

   > 1. 实现继承是指使用基类的属性和方法而无需额外编码的能力；
     2. 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
     3. 可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。 
  

  抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
  OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

package com.lanou.cmq;



public class Demo01 {

      // 创建一个Person 作为父类   定义一些属性和方法
      // 创建两个子类 Employe Student


     // 为什么要继承， 因为要提高代码的重复性，避免代码的重复出现
    // JAVA 中不支持多继承，如果需要多继承使用接口
    //private 修饰的成员不能被继承  子类中如果需要访问 可以用 set get方法

    public static void main(String[] args) {
        Student stu=new Student("小王","女",20);
//      stu.name="小明";
//      stu.age=21;
//      stu.gender="女";
        stu.sayHello();


    }
}

    class Person{
        String name;
        String gender;
        int age;

        public Person (String name,String gender,int age) {
            this.name=name;
            this.age=age;
            this.gender=gender;
        }

        public void eat(){
            System.out.println("吃饭");
        }

        public void sleep() {
            System.out.println("睡觉");
        }
        public void  sayHello() {
            System.out.println("hello");

        }
    }
    //继承是全部继承，除父类final private定义的
    class Employe extends Person{
        public Employe(String name, String gender, int age) {
            super(name, gender, age);

        }

        String name;
        String gender;
        int age;


    public  void  sayHello() {
            System.out.println("hello,我是工人 我叫："+name);

        }
    }


    class Student extends Person{
        public Student(String name, String gender, int age) {
            super(name, gender, age);

        }



    public  void  sayHello() {
            System.out.println("hello,我是学生 我叫："+name);

        }
    }

• 多态

  多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
  两种实现方式：覆盖 重载
  覆盖：指子类重新定义父类的虚函数的做法。
  重载：指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

public class Demo8 {


    String name=null;
    int age=0;
    //构造方法
    public Demo8(String name,int age){
        this.name=name;
        this.age=age;

    }

    public static void main(String[] args) {
         Demo8 pDemo8=new Demo8("小明",1);
         System.out.println(pDemo8);

    }

    public String toString(){
        //重写 覆盖 指的是父类已存在的方法 子类进行修改
        //重载 指的是方法名相同，参数列表不同
        return "姓名:"+this.name + "年龄："+this.age;
    }

}

package com.lanou.cmq;

public class Polymorphic {

    public static void main(String[] args) {
        Dog g = new Dog();
        Cat c = new Cat();
        //g.eat();
        //c.eat();
        runEat(g);
        runEat(c);
        //向下转型前先进行类型判断 防止抛出异常
        if (c instanceof Animal) {
            System.out.println("C是动物类");
        }
    }

    //父类的引用指向子类（会自动向上转型  转型后的对象将会丢失特有的内容）
    static public void runEat(Animal d){
        d.eat();
    }
    static public void runEat(Dog d) {
        d.eat();
    }

    static public void runEat(Cat d) {
        d.eat();
    }
}

abstract class Animal {
    abstract public void eat();
    //将父类作为返回值类型  可返回任意子类对象
    public Animal get() {
        return new Cat();
    }
}

class Dog extends Animal {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("我是一只狗喜欢啃骨头");
    }
}

class Cat extends Animal {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("我是一只猫喜欢吃鱼");
    }
}
/**
 * 
 * 不同的对象执行相同的方法。将会不同的结果
 * 父类的引用指向子类（会自动向上转型  转型后的对象将会丢失特有的内容）
 * 在向下转型的过程中 如果类型匹配的话  会抛出异常
 */

• 抽象类
  只声明方法的存在而不去具体的实现它

public class AbstractDemo {

    public static void main(String[] args) {
        Wolf wolf = new Wolf();
        wolf.bark();

    }

}

abstract class Quanke {
    // 没有方法体的方法（没有大括号）叫做抽象方法 ｛｝是方法的方法体
    // 如果一个类中存在抽象方法，那么这个类也是抽象的 用abstract 修饰
    // 关键字abstract
    // 抽象类不能被实例化 必须由子类覆盖所有的抽象方法后才能实例化
    abstract public void bark();

    // 在抽象类中可以定义非抽象方法
    public void sleep() {
        System.out.println("躺着睡觉");
    }
    // 抽象类中没有构造方法
    // abstract不可以与那些关键字一起用 ,如private static final
    // final abstract public void test() {}
}

// 当一个类继承自一个抽象类的时候必须覆盖抽象方法
// 否则这个子类还是抽象类
class Wolf extends Quanke {
    @Override
    public void bark() {
        System.out.println("嗷嗷...");
    }
}

• final类
  关键字final修饰的类 不能被继承 不能被实现，很多时候是为了程序的安全性，将一些重要的类声明为final类
• 接口
  Java只支持单重继承，不支持多重继承，即一个类只有一个父类。很多问题不好解决
  Java提供接口来实现类的多重继承。

    /**
     * 定义接口使用interface关键字
     * 接口也不能实例化 需要子类实现所有的方法后才能实例
     * 可以看作一种特殊的抽象类
     * 只能定义常量和抽象方法
     * 接口可以继承别的接口 并且可以多继承
     */
public class InterfaceDemo {

    public static void main(String[] args) {
        //又想使用接口 又不想创建新的类
        //使用匿名内部类
        //在创建同时是相里面的 方法即可
//      new MyInterface() {
//                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
//          @Override
//          public void hello() {
//              System.out.println("我是匿名内部类");
//              
//          }
//      };

        MyInterface in =new MyInterface() {

            @Override
            public void hello() {
                System.out.println("我是匿名内部类");
            }
        };
        in.hello();
        //System.out.println();
    }


}
interface MyInterface{
    //在接口中定义的成员变量会自动加上 public static final 变成了常量
  public static final int a=100;
  //接口中不允许存在非抽象方法     编译会自动加上abstract 变成抽象的
  //
  public void hello();
}

interface Inter2{
    public void hello ();
}

class ImplementDemo implements MyInterface,Inter2{

    @Override
    public void hello() {
        System.out.println("我是接口实现类");

    }}
//接口可以继承别的接口 并且可以多继承
interface ZInterface extends MyInterface{}

小练习

package com.lanou.cmq;

//设计一个USB接口使鼠标键盘能接入到PC类中进行使用

public class InterfaceExecise {

    public static void main(String[] args) {
        Computer computer=new Computer();
        computer.start();
        computer.addDevice(new Mouse());
        computer.stop();
    }
}

interface USB {
    public void open();
    public void close();
}

class Computer {
    public void  start(){
        System.out.println("电脑启动！");
    }
    public void stop() {
        System.out.println("电脑关机！");
    }

    //遵守接口规则
    public void addDevice (USB u) {
        u.open();
        u.close();
    }
}
class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标启动！");

    }

    @Override
    public void close() {
        System.out.println("鼠标关闭！");
    }
}