Java学习----day6——（1）面对对象程序设计进阶篇之继承篇

继承基本概念

extends，很好理解嘛，就是儿子继承父亲的属性；所以父类有什么，子类就有什么属性。

继承实现的限制问题

规范：只能一次继承一个父类！即在过程中一对一继承！

子类实例化的过程

当使用new关键字实现类的时候，先调用父类的构造器再调用子类构造器。（因为对象初始化就是构造函数的调用过程）

方法的覆写

private<default<public
private——>public
default——>public
就是直接在子类中定义同样的方法名并且扩大或者不动（父类>=子类）方法访问权限，进而具体实现。
private——>default不算是方法的覆写

super关键字

代表父类的意思，和this的意义差不多吧，但是需要注意的是，this在子类中找不到对于的方法和变量，将去父类中寻找。

package com.Example.chapter05;

 /**
 1. @author Administrator 
 2. @function : 继承的初步理解 
*/ 
public class ExtendsDesign {
     public static void main(String[] args) {
        Student guangwei=new Student();
        guangwei.setName("光唯");
        guangwei.setAge(23);
        guangwei.setSex("男");
        System.out.println(guangwei.getName()+"\t\t"+guangwei.getAge()+"\t\t"+guangwei.getSex());
    }

}
class Person{
    private String  name;
    private int age;
    private String  sex;
    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 String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

}
class Student extends Person{

}

抽象类abstract

package com.Example.chapter05;
 /**
  * @author Administrator 
  * @date : 2017年3月26日 下午9:53:27
  * @function : 抽象类的了解 
*/ 
public class AbstractDesign {
 public static void main(String[] args) {
    Demo2 A=new Demo2();
    A.outPut();
}
}
abstract class Demo{
    private int age=0;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    /*************抽象类********************/
    public abstract void outPut();

}
class Demo2 extends Demo{

    @Override
    public void outPut() {
        // TODO Auto-generated method stub
        System.out.println("Demo2继承抽象类Demo去实现实例化");
    }

}

    抽象类相当于“模板”，提供一个模板供子类去实现。       
  1. 有抽象方法的类必须是抽象类
  2. 抽象类和抽象方法都必须用abstract修饰
  3. 抽象方法不能具体实现
  4. 抽象类需要子类去实例化

   我们通过了解抽象类来和普通类进行区别一下，抽象类无非是需要abstract进行修饰，并且有抽象方法的类一定是抽象类。抽象类不一定必须要有抽象方法。

4.接口interface

接口是一种特殊的类；

package com.Example.chapter05;
 /**
  * @author Administrator 
  * @date : 2017年3月26日 下午10:07:55
  * @function : 接口的理解 
*/ 
public class InterfaceDesign {
 public static void main(String[] args) {
    Test t=new Test();
    System.out.println(t.getAge()+"\t"+t.getSex());

}
}
class Test implements Demo1,Demo2{

    @Override
    public int getSex() {
        // TODO Auto-generated method stub
        return sex;
    }

    @Override
    public int getAge() {
        // TODO Auto-generated method stub
        return age;
    }

}
interface Demo1{
    public  static final int age=20;
    public  abstract int getAge();
}
interface Demo2{
     public  static final int sex=0;
     public  abstract int getSex();
}

在接口中，变量必须为全局（static）常量（final）；
方法必须为抽象方法；与继承不同的是可以多重接入接口；（最重要的是常量和方法默认和要求必须是public权限）

5. 对象的多态性（——–>多种形态）

    1.方法的覆写
    （要把握覆写和实现的区别，抽象类不能叫做覆写）
    2.上下转型   
    对象是new出的在于堆内存中部分，
      对象向上转（数据类）型：父类类型 标识符=子类对象
      对象向下转（数据类）型：子类类型 标识符=（子类类型）父类对象（显示转换类型）
      对象在向下转型必须先向上转型；

package com.Example.chapter05;
 /**
  * @author Administrator 
  * @date : 2017年3月27日 上午11:29:15
  * @function : 主要是看重多态性的表现。上转型和下转型 
*/ 
public class DifferentVisionDesign {
   public static void main(String[] args) {
    A a=new B();
    a.outPut();
    B b=(B)a;
    b.outPut();
}
}
class A{
    public void outPut(){
        System.out.println("A类在此"+"\n---------------------------");
    }
}
class B extends A{
    public void outPut(){
        System.out.println("B类在此"+"\n---------------------------");
    }
}

常见设计模式

1.首先无疑是抽象类和接口的使用，他们先制定标准再给子类（extends，inmplements）具体实现。
2.制定标准

这里写图片描述

package com.Example.chapter05;
 /**
  * @author Administrator 
  * @date : 2017年3月27日 上午11:52:55
  * @function : 制定标准 
  *             1.电脑接收USB接口
  *             2.USB分为盘和打印机  
*/ 
public class DesignMode {
   public static void main(String[] args) {   
    Computer worker=new Computer();
    worker.start(new UDevice());
    worker.start(new Printer());
}
}
class Computer{
    public void start(USB device){
        device.work();
        device.finish();
    }
}
interface USB{
    public  abstract void work();
    public  abstract void finish();
}
class UDevice implements USB{

    @Override
    public void work() {
        // TODO Auto-generated method stub
        System.out.println("U盘开始工作"+"\n--------------------------");
    }

    @Override
    public void finish() {
        // TODO Auto-generated method stub
        System.out.println("U盘停止工作"+"\n--------------------------");
    }

}
class Printer implements USB{

    @Override
    public void work() {
        // TODO Auto-generated method stub
        System.out.println("打印机开始工作"+"\n--------------------------");
    }

    @Override
    public void finish() {
        // TODO Auto-generated method stub
        System.out.println("打印机停止工作"+"\n--------------------------");
    }

}

 3.工厂模式（产生一个工厂类，在里面拿具体实例）
 问题展示：

package com.Example.chapter05;
 /**
  * @author Administrator 
  * @date : 2017年3月27日 下午12:21:39
  * @function : 工厂类理解 
*/ 
public class FactoryDesign { 
    public static void main(String[] args) {
        Personk instance=null;
        instance=new man();
        instance.say();
        instance=new woman();
        instance.say();     
    }
}
class Personk{
    public void say(){

    }
}
class man extends Personk{

    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("男人说话女人不要插嘴");
    }

}
class woman extends Personk{

    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("女人说话男人不要插嘴");
    }

}

这里写图片描述

 所以很容易发现哦，在主方法中，每次去实例化一个类都要单独去实现才能调用方法；而且这个实例完全是可以使用类似于单例模式（解决构造方法私有化）；

package com.Example.chapter05;
 /**
  * @author Administrator 
  * @date : 2017年3月27日 下午12:21:39
  * @function : 工厂类理解 
*/ 
public class FactoryDesign { 
    public static void main(String[] args) {
        Personk instance=null;
        instance=new Factory().getInstacne("man");  
        instance.say();
    }
}
class Factory{
    public Personk instance=null;
    public Personk getInstacne(String classname){
        if(("man").equals(classname)){
            this.instance=new man();         
        }else if(("woman").equals(classname)){
            this.instance=new woman();
        }
        return this.instance;
    }
}
class Personk{
    public void say(){

    }
}
class man extends Personk{

    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("男人说话女人不要插嘴");
    }

}
class woman extends Personk{

    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("女人说话男人不要插嘴");
    }

}

4.代理模式

Object类详解
包装类的作用以及自动装箱和拆箱的操作
匿名内部类

final关键字

就此定义为终结者。end of everything！一经定义不得修改！他可以用来修饰类。

11.instanceof关键字

判断哪个对象是否属于哪个实例；
对象 instanceof 类名 ——>boolean类型值

posted @ 2017-03-26 16:03 理工物联网阅读(100) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

理工物联网

Java学习----day6——（1）面对对象程序设计进阶篇之继承篇

公告