心得感悟

感觉今天仍然是需要多加理解的一天，不过经过一次布置的程序编写作业后，自己的理解加深了。我自己也有在网上各种搜索，多看别人的文章，看看别人的理解，几百个答案里面总会有一个是让人满意的。

---

1.目的

• 一、了解代码块的用法
• 二、了解内部类的用法
• 三、了解继承的用法
• 四、了解多态的用法

2.内容简概

• 一、代码块的定义及用法
• 二、静态内部类的定义及用法
• 三、静态内部类改成普通内部类
• 四、普通内部类的使用
• 五、继承的定义及用法
• 六、多态的定义及用法

3.具体内容

• 一、代码块的定义及用法

1. 定义：
代码块是一种常见的代码形式，即用大括号“｛｝”将多行代码封装在一起，形成一个独立的代码区。

2. 为什么要用代码块？
当我们想在创建一个对象之前先做点准备工作，我们可以使用构造函数、静态变量或者静态方法，除此之外，我们还可以使用代码块，代码块会在对象创建之前就优先被调用。

3. 代码块的类型
（1）静态代码块：指用static关键字修饰的代码块，方法中不能存在静态代码块
（2）构造代码块：直接写在类中的代码块
（3）普通代码块：直接写在方法体中的代码块

4.执行顺序：静态代码块>构造代码块>构造方法>普通代码块
 同类型的代码块若出现多次，则按出现的先后顺序执行

5. 代码块和构造方法的书写格式
  (修饰符){
    预先执行的内容
   }
 
（1）静态代码块
静态代码块里面不能调用成员变量和实例方法，且只运行一次。

static {
        System.out.println("静态代码块");
}

（2）构造代码块
构造代码块在创建对象时被调用，每次创建对象都会调用一次（和静态代码块的区别是少了static修饰）

{
        System.out.println("构造代码块");
}

（3）普通代码块
普通代码块最常见，即在方法中用{}括起来的代码的集合。

class Person{
    public void Student(){
            System.out.println("普通代码块");
    }
}

（4）构造方法
构造函数的命名必须和类名完全相同，它没有返回值，也不能用void来修饰。构造函数不能被直接调用，必须通过new运算符在创建对象时才会自动调用。

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

• 二、静态内部类的定义及用法

1. 什么是静态内部类？
Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。而静态内部类就是用static修饰的内部类。

2. 什么时候用内部类？
当我们想把一个类的部分功能抽离除来，但是抽出来后，程序的可读性又变差了，这时候我们就需要内部类来解决这种情况。

3. 静态内部类的编写
在此，我们写一个管理界面视图的类，在界面中各个图标的相对位置的计算是比较复杂的，故我们可以把它抽出来成为内部类。

class RelativeLayout{
    String view;
    LayoutParams layoutParams;//存视图方法一

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

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

        public  LayoutParams(float leftMergin,float topMergin,float rightMergin,float bottonMergin){
            this.leftMergin = leftMergin;
            this.topMergin = topMergin;
            this.rightMergin = rightMergin;
            this.bottonMergin = bottonMergin;
        }
    }
}
//外部调用
class testLayout{
   public static void main(String[] args){
       //创建一个相对布局 容器视图
       RelativeLayout rl = new RelativeLayout();

       rl.view = "分享按钮";

        //显示这个视图
        //使用匿名对象 只需要使用一次
        rl.show(new RelativeLayout.LayoutParams(1,2,3,4));

        System.out.println();

        TestInner ti = new TestInner();
        ti.test();
   }
}

• 三、静态内部类改成普通内部类

1. 为什么要改成普通内部类？
内部类其实主要就是给内部使用的，如果要给外部使用，就用static修饰，但是若加上有时倒不如直接写出来，定义成内部类反而不利于外部的使用了。

2. 如何操作？
这里的LayoutParams类和上面的相比，上面的布局对象是外部创建的，而这里是内部创建的，只提供给内部使用，封装性更好。

class RelativeLayout{
    String view;
    LayoutParams layoutParams;
    
    public void show(float left,float top,float right,float botton){
        layoutParams = new LayoutParams(left,top,right,botton);
        System.out.println("视图"+view+"显示出来了");
        System.out.println("left:"+left+"top:"+top+"right:"+right+"botton"+botton);
    }

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

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

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

       rl.view = "分享按钮";
       rl.show(20,20,20,20);

        System.out.println();

        TestInner ti = new TestInner();
        ti.test();
   }
}

• 四、普通内部类的使用

1.普通内部类和静态内部类的区别
普通内部类在非静态类内部可以访问外部类的成员，而静态内部类不能访问外面的方法和成员。下面为普通内部类的使用例子：

class TestInner{
    int a;
    static int b;
    Inner inner;

    class Inner{
        //非静态的内部类 可以访问外部类的属性和方法
        public Inner(){
            a = 20;
            b = 30;
            show();
        }
    }
    public void test(){
        inner = new Inner();
    }

    public void show(){
        System.out.println("a = "+ a +"b = "+ b);
    }
}

• 五、继承的定义及用法

1. 定义
继承就是子类继承父类的对象和方法

2. 什么时候用继承？
当你想要获得父类的方法和属性，并且需要添加自己的属性和方法时，用继承可以简化程序的编写。

3. 类的继承书写格式
class 父类 {
}
class 子类 extends 父类 {
}

4. 继承的一些关键字
虽然Java中只能单继承，但我们可以变相地多继承，即使A继承B，C继承B，D继承C，实际上他们都是在继承A（若不添加其他属性和方法）

关键字	作用
extends	继承，一个子类只能拥有一个父类
this	指向自己的引用
super	实现对父类成员的访问，用来引用当前对象的父类。
final	可以把类定义为不能继承的，即最终类，不能被子类重写。

5. 继承的实例
下面就来举一个实际的例子，我们定义一个Person类，而学生、老师等都属于Person，即编写学生、老师的类时，可以继承Person类。首先，我们先编写一个父类Person，定义一些基本的属性个方法。

class Person {
    public String name;
    protected int age;

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

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

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

然后我们再来编写子类Student。额外的属性用this关键字修饰。

class Student extends Person{
    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 show() {
        System.out.println("name:"+name);
    }

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

    @Override
    public void eat(){
        System.out.println("学生小口吃饭");
    }
    //打印的方法二
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                ", school='" + school + '\'' +
                '}';
    }
}

• 六、多态的定义及用法

1. 定义
即同一个方法不同的实现，或者说在不同的子类中，有不同的实现。

2. 多态的使用
如果有继承关系：子类的对象可以使用父类变量接收。结合下面的输出理解。

class TestExtends{
    public static void main(String[] args){
        C testc = new C();
        A testc2 = new C();
        //上面两种输出均为“in C”
        testc2.info();
    }
}
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");
    }
}