Fei

非淡泊无以明志，非宁静无以致远

发表于 更新于 分类于

从五月份开始直至昨天，断断续续读完了这本书，但这个过程还是过于走马观花。因为是走马观花，所以大部分的内容根本没有深入理解，更谈不让将之运用于实践了。不过我知道这是一本好书，一本对于我的个人发展是一本好书，它能指导我的阅读。而阅读本本身可以让我获取更多的思想以及思考方式，所以重读这本书是很有必要的。而在这里，我也需要通过写读书笔记的方式来辅助我对这本书对我有利的内容尽可能多地进行吸纳。

我会按照这本书的结构来进行读书笔记的书写，除了对于文中重要内容的复述，也会加入我个人新的思考。

第一篇 阅读的层次

第1章 阅读的活力与艺术

本书的目的是为了那些以增进自己理解力为目标而阅读的人提供指导

  • 主动地阅读

​ 阅读越主动，收获也就越多

​ 作者与读者的关系就如同发球手和捕球手的关系一样。作者“发出”某个思想，读者需要主动地去“捕 获”这个思想。

​ 首先，阅读需要主动。其次，阅读需要有技巧。

发表于 更新于 分类于

1. 易忘知识点

用于记录已遗忘的知识点

1.1 基础语法

  • 一个JAVA文件中的不同类中均可以有public static 方法， 并且可用java 类名的方式运行public static方法

  • javadoc 用于生成java文件的文档，使用方式javadoc xxx.java.

  • 补码 = 反码 + 1， 计算机运行使用补码

    • 正数：原码，反码，补码都一样：第一位是符号位，0代表正数，数值位为二进制数
    • 负数：
      • 原码：第一位是符号位，1代表负数，数值位为2进制数
      • 反码：第一位是符号位，1代表负数，数值位为对应原码的数值位取反
      • 补码：反码数值位加1

  • 方法重载（Overload）

    • 方法名必须相同

    • 形参列表必须不同：参数顺序，类型，个数，至少有一样不同

    • 返回类型：无要求

      注意：仅仅是形参名不同无法实现方法重载

  • 可变参数

    java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法

    1
    2
    3
    public void varPara(int... parameters){
      //parameters 是一个数组
    }
    1. 可变参数的实参可以为0或任意多个
    2. 可变参数的实参可以是数组
    3. 可变参数可以和普通类型的参数放在一个形参列表里，但需要保证可变参数在最后
    4. 一个形参列表中只能出现一个可变参数

  • 构造器

    • 构造器没有返回值
    • 方法名和类名必须相同
    • 参数列表和成员方法一样的规则
    • 构造器的调用由系统完成
    • 构造器，即构造方法可以重载
    1
    2
    3
    4
    5
    class Constructer{
      public Constructer(){
        
      }
    }

    作用：对新对象的初始化

  • 反编译

    javap [-c -v] 类名

    -c 对代码反汇编

    -v 输出附加信息

1.2 面向对象

  • 代码块

    属于类中的成员，将逻辑语句封装在方法体中，通过“{}”包围起来。

    和方法不同，没有方法名，没有返回值，没有参数，只有方法体，不通过类或对象显式调用。在加载类或者创建对象时隐式调用。

    1
    2
    3
    [修饰符]{
      code...
    }; // 此分号可有可无

    修饰符 可选，使用修饰符时只能用static

    代码块使用场景：e.g. 当多个构造器中有相同的代码语句时，可以将其放入代码块中

    创建对象时，系统先调用代码块，后调用构造器

  • 类加载顺序

    1. 父类的静态代码块和静态属性
    2. 子类的静态代买块和静态属性
    3. 父类的普通代码块和普通属性
    4. 父类的构造方法
    5. 子类的普通代码块和普通属性
    6. 子类的构造方法

  • final关键字

    使用情况:

    (1) 当一个类不希望被继承时, 可使用final关键字修饰

    (2) 当不希望类中某个方法被子类重写时, 可用final关键字修饰

    (3) 当不希望类中某个属性的值被修改时, 使用final关键字修饰

    (4) 当不希望某个局部变量被修改时, 使用final关键字修饰

  • abstract 类

    当不打算在父类中定义某些方法,但又想提前声明这些方法时, 使用abstract修饰这个父类以及这些方法

    1
    2
    3
    class abstract Test{
      public abstract void m(); // 没有方法体
    }

    • interface

      JDK8.0后接口可以有静态方法, 默认方法

      在接口中抽象方法可以省略abstract关键字

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      public interface Test{
         public int n1 = 10;
         default public void ok(){ // 默认方法, 注意要使用default关键字修饰
           System.out.println("ok..");
         }
        public static void test(){ // 静态方法
          System.out.println("test.."); 
        }
      }

      一个类可以同时实现多个接口

      1
      2
      3
      class Test implements IA, IB, ...{
        ...
      }

      接口中的属性是final static修饰的, 例如在接口中写int a = 1; , 实际上是public static final int a = 1;

  • 内部类

    一个类的内部又完整地嵌套了另一个类结构. 被嵌套的类称为内部类(inner class), 嵌套的其他类称为外部类(outer class). 

    1
    2
    3
    4
    5
    6
    // 基本语法
    class Outer{// 外部类
      class Inner{// 内部类
        
      }
    }

    内部类的分类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    //1. 定义在外部类的局部位置(如方法中, 代码块中)
    //1.1 局部内部类
    class Outer01{
      private int n1 = 1;
      public void m1(){
        class Inner01{ // 可使用final修饰
          private int n1 = 22;
          public void m10(){
            System.out.println(A.this.n1); // 可以直接访问所在外部内的所有成员, 使用 外部类名.this精确定位
          }
        }
      }//局部内部类的作用域只在对应的方法体内或代码块中
    }

    //1.2 匿名内部类
    class Outer02{
      private int n2 = 1;
      public void m2(){
        IA ia = new IA(){ // class xxx implements IA{...}
          public void test(){
            System.out.println(n2);
          }
        }
      }
    }
    interface IA{}

    //2. 定义在外部类的成员变量位置
    //2.1 成员内部类

    class Outer03{
      private int n3 = 1;
      class Inner{
        public void m3(){
          System.out.println(n3);
        }
      }
    }

    //2.2 静态内部类

    class Outer04{
      private int n4 = 1;
      static class Inner{
        public void m4(){
          System.out.println(n4);
        }
      }
    }

  • 枚举

枚举: 枚举属于一种特定的类, 里面只包含一组有限的特定的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//1. 自定义枚举

class Season{
    private String name;
    private String desc;
    // public Season season = new Season("ok", "001");


    public static final Season SPRING = new Season("Spring", "Warm");
    public static final Season SUMMER = new Season("Summer", "Hot");
    public static final Season AUTUMN = new Season("Autumn", "Cozy");
    public static final Season WINTER = new Season("Winter", "Cold");

    private Season(String name, String desc){
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
}







//2. 使用enum关键字


enum Season_{
    //1. 多个常量时， 用','间隔
    //2. 常量对象需要定义在类的最前面

    SPRING("Spring", "Warm"), SUMMER("Summer", "Hot"), AUTUMN("Autumn","Cozy"), WINTER("Winter","Cold");
    
    private String name ;
    private String desc;
    private Season_(String name, String desc){
      this.name = name;
      this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
}

  • 注解

    注解(Annotation)也被称为元数据, 用于修饰包, 类, 方法, 属性, 构造器, 局部变量等数据信息

    不影响程序逻辑, 但是注解可以被编译和执行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //1. @Override 标明方法为重写方法
    //2. @Deprecated 标明某个类或方法已过时
    //3. @SuppressWarnings 抑制编译器警告


    //元注解, 注解的注解
    //1. @Retention(RetentionPolicy.SOURCE)  指定注解的作用范围(SOURCE(编译器使用后直接丢弃), CLASS(记录在class文件, 但jvm运行时不保留), RUNTIME)
    //   代码(SOURCE) ==> class 文件(class) ==> JVM运行(RUNTIME)
    //2. Target(ElementType.METHOD) 指定注解的使用范围(CONSTRUCTURE, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE)
    //3. Documented 指定该注解是否在javadoc中显示
    //4. Inherited 子类会继承父类注解

    • 异常

      运行时异常: 程序运行时发生异常

      编译时异常: 编译器检测出的异常

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Java.lang.Throwable
      -Error
      -Exception
      	--编译时异常
      		--IOException
      		--SQLException
        --运行时异常 RuntimeException
      		--NullPointException
      		--ArrayindexOutOfBundsException
      		--ArithmeticException
      		--ClassCastExcetption
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    // 1. try-catch-finally
    try{
      ...
    }catch(NullPointerException e){
      e. sss;
    }catch(ArithmeticException e){
      
    }finally{
      
    }

    // 2. throws

    public void method() throws {
      
    }
    //当抛出的是运行时异常, 调用该方法的方法可以不处理
    //当抛出的是编译时异常, 调用该方法的方法需要进行处理

发表于 更新于 分类于

文章管理

2023年9月19日生效

时间-文章类型-文章名称

文章类型：

  • 日记随想：D : Thoughts

  • 总结反思：S : Summary

  • 技术文章：T : Tech

  • 读书笔记：R : Reading

  • 效率管理：E : Efficiency

日记： 记录一天经历的事件或所思所想

技术文章：整理所学到的技术知识, 以及技术相关的工作学习收获

读书笔记：整理每次阅读完一本书的知识点或者读后感。对于论述性书籍进行总结归纳，对于文学类书籍写读后感

效率提升：记录能提升知识输入输出的方式。比如本文档可归为此分类。因为本文档用于阐述我所写文章的分类方式。

发表于 更新于 分类于

前言

简介

金字塔原理是美国作家芭芭拉·明托在1966年所著，她是著名咨询公司麦肯锡聘用的第一位女性咨询顾问。金字塔原理是她在1966年被派往英国，担任负责麦肯锡欧洲员工写作能力的职位后总结得出的。金字塔原理介绍了一种能清晰表达思路的有效方法。掌握了金字塔原理，就能在各行各业的各种事务中，重点突出，逻辑清晰地实现与相关人员的高效沟通。

我们都希望在思考，沟通表达，处理多种事务时能重点突出，思路清晰，层次分明。我们希望在表达时能正面准确的回应受众的问题。而金字塔原理这本书能够帮助我们实现这些愿景，用最高效的方式表达自己的观点。

译者导言

金字塔原理的基本结构是：结论先行，以上统下，归类分组，逻辑递进。先重要后次要，先总结后具体，先框架后细节，先论点后论据。

金字塔原理的具体做法是自上而下表达，自下而上思考，纵向总结概括，横向归类分组，序言讲故事，标题提炼思想精华。

序言

金字塔结构中，各种思想只有向上，向下，或横向的几种非常少的逻辑关系。思想是句子和段落要表达的内容。在开始表达前，先将自己的思想组织成金字塔结构，并按照逻辑关系的规则进行检查和修改。

发表于 更新于

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post" # 需要在根目录下执行

More info: Writing

Run server

1
$ hexo server # 需要在根目录下执行

More info: Server

Generate static files