2019-08-10 Day11 代码块、内部类与继承

目的

学习代码块的原理，明白怎么使用它和理解它的加载顺序，简单了解；辨析内部类和外部类，学习内部类的基础知识，掌握内部类的使用方法和作用，剖析其具体体现；进入Java三特性之一——继承，学习其基础特征，加深对继承特性的理解

代码块

在程序编程中，可以直接使用“{}”定义一段语句。根据定义的位置以及声明关键字的不同，可以分为四种：普通代码块、构造代码块、静态代码块和同步代码块。一般来说代码块是不能单独运行的，它必须要有运行主体。其形式大致为：

修饰符 {
预先执行的内容，即预处理
  }

在对象创建之前，代码块就会被优先调用

实例

class Person{
    int age;
    
    //普通代码块
    {
        age = 30;
        System.out.println("代码块 age="+age);
    }

    //静态代码块
    static {
        //age = 20;静态代码块里面不能调用成员变量和实例方法
        System.out.println("静态代码块");
    }

    public Person(){
        System.out.println("无参构造方法 age="+age);
    }

    public Person(int age){
        this.age = age;
        System.out.println("有参构造方法");
    }
}

内部类

概念

向对象程序设计中，可以在一个类的内部定义另一个类，这种类称为嵌套（nestedclasses）,它有两种类型，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。

定义一个类，可以在多个地方定义

  1. 单独创建一个文件管理一个类
  2. 直接在文件里面，类A的上面和下面创建
  3. 直接在某个类A内部创建一个类

实例

class RelativeLayout{
    String view;

    //在显示一个视图前 必须告诉系统这个视图的具体位置
    public void show(LayoutParams layout){
        System.out.println("视图:"+view+"显示出来了");
                System.out.println("left:"+layout.leftMergin+
                        "top:"+layout.topMergin+
                        "right:"+layout.rightMergin+
                        "bottom:"+layout.bottomMergin);
    }

    //定义一个内部类 用于管理相对布局的具体布局属性
    public static class LayoutParams{
        float leftMergin;
        float topMergin;
        float rightMergin;
        float bottomMergin;

        public LayoutParams(float leftMergin, float topMergin,
                            float rightMergin, float bottomMergin){
            this.leftMergin = leftMergin;
            this.topMergin = topMergin;
            this.rightMergin = rightMergin;
            this.bottomMergin = bottomMergin;
        }
    }
}

静态内部类的使用

class testLayout{
    public static void main(String[] args){
        //创建一个相对布局 容器视图
        RelativeLayout rl = new RelativeLayout();

        rl.view = "分享按钮";

        //显示这个视图
        //准备好这个视图的布局属性
        //1.
//        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(20,20,
//                20,20);
//        rl.show(params);
        
        //使用匿名对象 只需要使用一次
        rl.show(new RelativeLayout.LayoutParams(20,20,
                20,20));
    }
}

运行结果

1.png

继承

概念

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。

关键 获得父类的方法和属性，并需要添加自己的属性和方法；Java里面只能单继承，以及变相多继承

需要关注点

1.所有类都是直接或间接继承于Object类
2.当调用子类的一个方法时，如果没有就会到父类里面去查找
3.如果子类里面需要调用父类的方法，或者显示调用父类的属性的时候，使用super

    @Override
    public void walk() {
        super.walk();
    }

4.如果一个方法需要完成一个功能，又不能单独完成，必须要父类做相应工作，就需要调用super的对应方法
父类做完之后，子类再操作

2.png

子类做点事情之后，调用父类去完成
3.png

  1. 如果子类里面需要重新实现父类的方法，就需要使用@Override重写
    @Override
    public void walk() {
        System.out.println("学生走路");
    }
  1. 如果父类有自定义构造方法,子类的构造方法里必须显示调用父类的构造方法
  2. 如果父类有内部类,子类中有同名的内部类,那么父类中的内部类就被屏蔽了;如果非要使用父类中的内部类,只能使用全类名

实例

父类

class Person1{
    protected String name;
    protected int age;

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

    public void walk(){
        System.out.println(name+"走路");
    }

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

子类

class Student extends Person1{
    int id;
    String school;

    public Student(String name, int age, int id, String school){
        super(name, age);
        this.id = id;
        this.school = school;
    }

    public void study(){
        System.out.println("name:"+name);
    }

    //方法的重写
    @Override
    public void walk() {
        System.out.println("学生走路");
    }

    @Override
    public void eat() {
        System.out.println("学生吃饭");
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                " name='" + name + '\'' +
                ", age=" + age +
                ", school='" + school + '\'' +
                '}';
    }
}

运用

class TestExtends{
    public static void main(String[] args){
        //Student xw = new Student();
        //xw.name = "Jack";
        //xw.age = 20;
        //xw.id = 001;
        //xw.school = "西南大学";

        Student xw = new Student("Jack",20,001,"西南大学");

        xw.walk();

        System.out.println(xw);
    }
}

多态

多态是同一种方法，有多种实现的能力；相同于一个方法在不同的子类中有不同的实现

多态的存在有三个前提：
1.要有继承关系
2.子类要重写父类的方法
3.父类引用指向子类对

实例

class A{
    public void info(){
        System.out.println("in A");
    }
}

class B extends A{
    @Override
    public void info(){
        System.out.println("in B");
    }
}

class C extends A{
    @Override
    public void info(){
        System.out.println("in C");
    }
}

运用

4.png

注意 如果两个类有继承关系，子类的对象可以使用父类的变量接受（类型的自动向上转换）

demo

5.png
public class Person2 {
    protected String name;
    protected int age;

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

    public void walk(){
    }

    public void eat(){
    }
}

class CivilServant extends Person2{
    private int salary;
    private int count;

    public CivilServant(String name, int age,
                        int salary, int count){
        super(name, age);
        this.salary = salary;
        this.count = count;
    }

    @Override
    public void walk() {
        System.out.println("慢慢地走");
    }

    @Override
    public void eat() {
        System.out.println("大吃大喝");
    }


    public void cShow() {
        System.out.println("CivilServant{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", count=" + count +
                '}');
    }
}

class Worker extends  Person2{
    private int salary;
    private String tec;

    public Worker(String name, int age, int salary,
                  String tec){
        super(name, age);
        this.salary = salary;
        this.tec = tec;
    }

    @Override
    public void walk() {
        System.out.println("快跑呢");
    }

    @Override
    public void eat() {
        System.out.println("急匆匆吃");
    }

    public void wShow() {
        System.out.println( "Worker{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", tec='" + tec + '\'' +
                '}');
    }
}

class Test3{
    public static void main(String[] args){
//        Person[] peoples = new Person[6];
        ArrayList<Person2> peoples = new ArrayList<>();

        Person2 c1 = new CivilServant("小王", 30, 5000, 30);
        Person2 c2 = new CivilServant("小李", 32, 7000, 34);
        Person2 c3 = new CivilServant("张三", 33, 2000, 32);

        //peoples.add((Person2)c1);
        peoples.add(c1);
        peoples.add(c2);
        peoples.add(c3);

        Person2 w1 = new Worker("Jack",23,8922, "Android开发");
        Person2 w2 = new Worker("Rose",22,10323, "iOS开发");
        Person2 w3 = new Worker("Merry",20,8123, "web开发");

        peoples.add(w1);
        peoples.add(w2);
        peoples.add(w3);

        for (Person2 p: peoples){
           //找到p到底是哪个类型的对象
            if(p instanceof CivilServant){
                //公务员
                CivilServant c = (CivilServant)p;
                c.cShow();
                c.walk();
                c.eat();
            }else{
                //员工
                Worker w = (Worker)p;
                w.wShow();
                w.walk();
                w.eat();
            }
        }
    }
}

心得体会

今天学习了子类、父类，明白了继承是怎么一回事，为以后减少了不少事；但是还是对内部类不太明白，还需要消化

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • Java学习之继承、内部类与多态，包
    一、继承 当两个事物之间存在一定的所属关系，即就像孩子从父母那里得到遗传基因一样，当然，java要遗传的更完美，这...
    玉圣阅读 1,133评论 0赞 2
  • 面试题
    Swift1> Swift和OC的区别1.1> Swift没有地址/指针的概念1.2> 泛型1.3> 类型严谨 对...
    cosWriter阅读 11,804评论 1赞 32
  • 六、Kotlin 类与对象
    面向对象编程（OOP） 在前面的章节中，我们学习了Kotlin的语言基础知识、类型系统、集合类以及泛型相关的知识。...
    Tenderness4阅读 4,654评论 1赞 6
  • 2016年5月Swift 2 学习 --- 117个注意事项与要点
    这是16年5月份编辑的一份比较杂乱适合自己观看的学习记录文档，今天18年5月份再次想写文章，发现简书还为我保存起的...
    Jenaral阅读 3,238评论 2赞 9
  • Java基础知识整理
    整理来自互联网 1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具...
    Ncompass阅读 1,646评论 0赞 6

友情链接更多精彩内容