泽野之乡

发表于 更新于 分类于

浮动

  1. 浮动的基本概念
    • 垂直显示的浮动，不要设置浮动，只有并排显示的盒子才要设置浮动！
    • “大盒子带着小盒子跑”，一个大盒子中，又是一个小天地，内部可以继续使用浮动
    • 超市售卖的塑料袋0.3元一个，div是免费的！不要节约盒子
    • 本质
      • 浮动的最本质的功能：实现并排
      • 浮动的要点：要浮动，并排的盒子都要设置浮动
      • 父盒子要有足够的宽度，否则子盒子会掉下去
      • 浮动的顺序贴靠特性
        • 子盒子会按顺序贴靠，如果没有足够的空间，则会寻找再前一个兄弟元素
      • 浮动的元素一定能设置宽高
        • 浮动元素不在区分块级元素、行内元素，已经脱离了标准的文档流，一律能够设置宽度和高度，即使它是span标签或者标签等
  2. 使用浮动实现网页布局
  3. BFC规范和浏览器差异
    • BFC（ Box formatting Context）块级格式化上下文 是页面上的一个隔离的独立容器，容器里面的子元素不会影响到外面的元素，反之亦然
    • 从一个现象开始说起
      • 一个盒子不设置height，当内容的子元素都浮动时，无法撑起自身
      • 这个盒子没有形成BFC
      • 如何形成BFC
        • 1、float的值不是none
        • 2、position的值不是static或者relative
        • 3、display的值是inline-block、flex或者inline-flex
        • 4、overflow:hidden
          • 溢出隐藏，溢出盒子边框会隐藏
      • BFC的其他作用
        • BFC可以取消盒子的margin塌陷
        • BFC可以阻止元素被浮动的元素覆盖
      • 浏览器差异
        • IE6、IE7浏览器使用haslayout机制，和BFC规范略有差异，比如IE浏览器可以使用zoom:1属性，“让壳子拥有layout”
        • 如果要兼容IE6、IE7网页时，尽量让网页设计的简单。内部有浮动的盒子要设置height属性，规范编程，不要“玩杂技”
  4. 清除浮动
    • clear: both;
    • overflow:hidden

定位

  1. 相对定位
    • 相对定位：盒子可以相对自己原来的位置进行调整，称为”相对定位“
    • position: relative;
    • 值可以是负数，即往相反的位置移动
    • 相对定位的元素，会在“老家留坑”，本质上任然是在原来的位置，只不过渲染在新的地方而已，渲染的图形可以比如成“影子”，不会对其他元素产生任何影响
    • 相对定位的用途：用来微调元素位置。可以当做绝对定位的参考盒子。
  2. 绝对定位
    • 盒子可以在浏览器中，以坐标进行位置精准描述，拥有自己的绝对位置
    • position: absolute;
    • left 到左边的距离，right 到右边的距离，top 到上边的距离，bottom到下边的距离
    • 绝对定位元素脱离标准文档流，将释放自己的位置，对其他元素不会产生任何干扰，而是对它进行压盖
    • 脱离标准文档流的方法：浮动、绝对定位、固定定位
    • 绝对定位的参考盒子：绝对定位的盒子会以自己祖先元素中，离自己最近的拥有定位属性的盒子，当做基准点，这个盒子通常是相对定位的，所以这个性质也叫作 “子绝父相”
    • 绝对定位的盒子并不是永远以浏览器作为基点
    • 绝对定位的盒子垂直居中
      • position:absolute; top:50%; margin-top:-自己高度的一半
    • 堆叠顺序 z-index
      • 没有单位，数值大的就能压盖住小的
    • 绝对定位用途：“压盖”、“遮罩”效果，结合JS实现动画效果，“雪碧图”
  3. 固定定位
    • position: fixed;
    • 固定定位只能以页面为参考点，没有“子固父相”这个性质
    • 固定定位脱离标准文档流
    • 用途：返回顶部，楼层导航等

发表于 更新于 分类于

3D变形

  1. 3D旋转
    • 将transform的属性设置为rotateX()或者rotateY()，即可实现绕横轴、纵轴旋转
  2. 空间移动
    • 当元素进行3D旋转后，即可继续添加translateX()、translateY()、translateZ()属性让元素在空间进行移动
  3. perspective（景深）
    • 该属性用来定义透视强度，可以理解为“人眼到舞台的距离”，单位是px
      1
      2
      3
      4
      <div class="box1">
           <p></p>
       </div>
       <!-- div 是舞台，必须设置perperctive属性，p是演员，设置transform属性 -->
  4. transform-style（指定嵌套元素是怎样在三维空间中呈现。）
    • preserve-3d 表示所有子元素在3D空间中呈现。
    • flat 表示所有子元素在2D平面呈现。
      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
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
         <!DOCTYPE html>
         <html lang="en">
          <head>
          <meta charset="UTF-8">
          <meta name="viewport" content="width=device-width, initial-scale=1.0">
          <title>Document</title>
          <style>
              * {
                  margin: 0;
                  padding: 0;
              }
             section {
                  width: 200px;
                  height: 200px;
                  margin: 100px auto;
                  perspective: 10000px;
              }
              .box {
                  width: 200px;
                  height: 200px;
                  perspective: 10000px;
                  position: relative;
                  /* 设置变形类型，保留它内部的3D效果 */
                  /* 这个盒子又是舞台，又是演员，这个box整体带着里面的p旋转 */
                  transform-style: preserve-3d;
                  transition:all 10s ease 0s;
              }

              section:hover .box {
                  transform: rotateX(360deg) rotateY(360deg);
              }

              .box p {
                  position: absolute;
                  top: 0;
                  left: 0;
                  width: 200px;
                  height: 200px;
              }

              .box p:nth-child(1) {
                  background-color: rgba(219, 56, 211, 0.486);
                  /* 前面 */
                  transform: translateZ(100px);
              }

              .box p:nth-child(2) {
                  background-color: rgba(42, 128, 199, 0.486);
                  /* 顶面 */
                  transform: rotateX(90deg) translateZ(100px);
              }

              .box p:nth-child(3) {
                  background-color: rgba(56, 219, 83, 0.486);
                  /* 背面 */
                  transform: rotateX(180deg) translateZ(100px);
              }

              .box p:nth-child(4) {
                  background-color: rgba(213, 216, 32, 0.486);
                  /* 底面 */
                  transform: rotateX(-90deg) translateZ(100px);
              }

              .box p:nth-child(5) {
                  background-color: rgba(236, 82, 102, 0.486);
                  /* 侧面 */
                  transform: rotateY(90deg) translateZ(100px);
              }

              .box p:nth-child(6) {
                  background-color: rgba(119, 17, 236, 0.486);
                  /* 侧面 */
                  transform: rotateY(-90deg) translateZ(100px);
              }
          </style>
      </head>

      <body>
          <section>
              <div class="box">
                  <p></p>
                  <p></p>
                  <p></p>
                  <p></p>
                  <p></p>
                  <p></p>
              </div>
          </section>
      </body>
      </html>

2D变形

  1. 旋转变形
    • transform: rotate(45deg);
    • 若角度为正，就是顺时针，否则就是逆时针
    • transform-origin 属性设置自己的自定义变换原点
      • transform-origin: 50px 40px;
  2. 缩放变形
    • transform: scale(3);
    • 以中心点为原点缩放
  3. 斜切变形
    • transform: skew(10deg,20deg); 即可实现斜切变形
    • x的斜切角度，y的斜切角度
  4. 位移变形IE9
    • 将 transform 属性设置为 translate ，即可实现位移变形
      • transform: translate(200px,400px);
    • 和相对定位非常像，位移变形也会“老家留坑”，形影分离。

发表于 更新于 分类于

什么是异常

  1. 异常本质上是程序上的错误。
  2. 错误在我们编写程序的过程中会经常发生，包括编译期间和运行期间的错误。
  3. 在程序运行过程中，意外发生的情况，背离我们程序本身的意图的表现，都可以理解为异常。

Throwable（异常的根类）

  1. Error（Java 虚拟机出现问题）
    • Error 是程序无法处理的错误，表示运行应用程序中比较严重的问题。
    • 它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
    • 对于设计的合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。
    • 常见错误
      • 虚拟机错误 VirtualMachineError
      • 内存溢出 OutOfMemoryError
      • 线程死锁 ThreadDeath
  2. Exception
    • Exception 是程序本身可以处理的异常。异常处理通常指针对这种类型异常的处理。
    • 检查异常 Checked Exception
      • 编译器要求必须处置的异常。（编码阶段）
      • 除了 RuntimeException 及相关子类，其它异常都属于 Checked Exception
        • IO 异常 IOException
        • SQL 异常 SQLException
        • 等等
    • 非检查异常 Unchecked Exception
      • 编译器不要求强制处置的异常（运行阶段）
      • 包含 RuntimeException 及相关子类
        • 空指针异常 NullPointerException
        • 数组下标越界异常 ArrayIndexOutOfBoundsException
        • 算数异常 ArithmeticException
        • 类型转换异常 ClassCastException
        • 等等…
    • System.exit(1); 终止程序运行

throw & throws

  1. throws
    • 可以通过 throws 声明将要抛出何种类型的异常，通过 throw 将产生的异常抛出。
    • 如果一个方法可能出现异常，但没有能力处理这种异常，可以在方法声明处用 throws 子句来声明抛出异常。
    • throws 语句用在方法定义时声明该方法要抛出的异常类型。
    • 当方法抛出异常列表中的异常时，方法将不对这些类型及其子类类型的异常做处理，而抛向调用该方法的方法，由他去处理。
  2. throw
    • throw 用来抛出一个异常。
      • 例如：throw new IOException():
    • thorw 抛出的只能够是可抛出类 Throwable 或者其子类的实例对象。
      • 例如：throw new String(“出错了”); 是错误的
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        public void method(){
          try{
             // 代码段1
             throw new 异常类型();
           }catch(异常类型 ex){
              // 对异常处理的代码段2
           }
        }
        public void method()  throws 异常类型{
           // 代码段1
            throw new 异常类型();
        }
    • 作用
      • 规避可能出现的风险
      • 完成一些程序的逻辑
    • throw 抛出异常对象的处理方案
      • 通过 try…catch 包含 throw 语句 —— 自己抛出自己处理
      • 通过 throws 在方法声明抛出异常类型 —— 谁调用谁处理 —— 调用者可以自己处理，也可以继续上抛。此时可以抛出与 throw 对象相同类型或者其父类
      • 当子类重写父类抛出异常方法时，声明的异常必须是父类方法所声明异常的同类或子类。

自定义异常

  1. 基本概念
    • 使用 Java 内置的异常类可以描述在编程时出现的大部分异常情况。
    • 也可以通过自定义异常描述特定业务产生的异常类型。
    • 所谓自定义异常，就是定义一个类，去继承 Throwable 类或者它的子类
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      public class TestException extends Exception{
           public TestException(){
               super("向父类抛的异常消息");
           }
      }

      public static void test() throw TestException{
             <代码块>
             throw new TestException();
      }

异常链

  1. 基本概念
    • 有时候我们会捕获一个异常后在抛出另一个异常
    • 顾名思义就是：将异常发生的原因一个传一个串起来，即把底层的异常信息传个上层，这样逐层抛出。
  2. Exception e1 = new Exception(“异常消息”); e1.initCause(e);

如何处理异常

  1. 在 Java 应用程序中，异常处理机制为
    • 抛出异常（先抛出，才能被捕获）
    • 捕获异常
  2. 对于运行时异常，错误或可检查异常，Java 技术所要求的异常处理方式有所不同。
    • 1、对于可查异常必须捕捉、或者声明抛出
    • 2、允许忽略不可查的 RuntimeException（含子类）和 Error（含子类）
  3. 通过 5 个关键字来实现
    • 捕获异常
      • try（执行可能产生异常的代码）
      • catch（捕获异常）
      • finally（无论是否发生异常 代码总能执行）
    • 声明异常
      • throws（声明可能要抛出的异常）
    • 抛出异常
      • throw （手动抛出异常）
  4. 规则说明
    • try-catch-finally
      • try 块后可接零个或多个catch块，如果没有 catch 块，则必须跟一个finally块。
  5. 自定义异常
  6. 异常链

实际应用总结

  1. 处理运行异常时，采用逻辑去合理规避同时辅助 try-catch 处理
  2. 在多重 catch 块后面，可以加一个 catch（Exception） 来处理可能被遗漏的异常
  3. 对于不确定的代码，也可以加上 try-catch，处理潜在的异常
  4. 尽量去处理异常，切忌知识简单的调用 printStackTrace() 去打印输出
  5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定
  6. 尽量添加 finally 语句块去释放占用的资源（关闭文件、关闭 sql 链接）等

发表于 更新于 分类于

多态

  1. 基本概念
    • 同一种行为，在不同的对象上，会产生不同的显示结果。
    • 允许不同类的对象对同一消息做出不同的响应
    • 编译时多态
      • 设计时多态 方法重载
    • 运行时多态（通常说的这个）
      • 程序运行时动态决定调用哪个方法
    • 必要条件
      • 满足继承关系
      • 父类引用指向子类对象
  2. 使用
    • 父类引用子类实例
      • 向上转型、隐式转型、自动转型
      • 父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有方法。
      • 小类转型大类
      • 父类 static 方法，不允许子类重写
      • 向上转型后，只能调用到父类原有的静态方法
    • 子类引用指向父类实例
      • 向下转型、强制类型转换
      • 子类引用指向父类对象，此时必须进行强转，可以调用子类独有方法
      • 必须满足转换条件才能进行强转
        • 对象 instanceof 类
        • 判断对象是否是类的实例
          1
          2
          Animal  one = new Cat();
          Cat temp = (Cat)one
  3. 抽象类（abstract）
    • Java 中使用抽象类，限制实例化
      • 通过 abstract 修饰的类，就是抽象类
      • 不允许实例化，可以通过向上转型，指向子类实例
    • 通过abstract 修饰的方法，就是抽象方法
      • public abstract void eat();
      • 子类必须实现这个方法！
    • 应用场景
      • 某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
      • 避免设计随意性，无意义父类实例化
    • 使用规则
      • 1、abstract 定义抽象类
      • 2、抽象类不能直接实例化，只能被继承，可以通过向上转型完成对象实例
      • 3、abstract 定义抽象方法，不需要具体实现
      • 4、包含抽象方法的类是抽象类
      • 5、抽象类中可以没有抽象方法
      • 6、static final private 不能与 abstract 并存
  4. 接口（interface）
    • 基本概念
      • 接口定义了某一批类所需要遵守的规范
      • 接口不关心这些类的内部数据，也不关心这些类里的方法的实现细节，它只规定这些类里必须提供某些方法
    • 语法：
      • [修饰符] interface 接口名 [extends 付接口1, 父接口2…]
        1
        2
        3
        4
        5
        6
        {
           零个到多个常量定义...
           零个到多个抽象方法定义...
           零个到多个默认方法的定义.... (jdk1.8新增)
           零个到多个静态方法的定义... (jdk 1.8新增)
         }
    • 使用注意：
      • 一个类可以实现多个接口，通过逗号分割。 implements
      • 接口的实现要放在继承后面，一个类只能继承唯一父类，但可以实现若干个接口。实现接口的时候要去重写接口待重写的方法。否则通过 abstract 定义抽象类
      • 接口也可以实现继承关系，并且可以继承多个父接口，用逗号分开
      • 如果继承多个接口有多个重名的方法，子类不知道该实现哪个接口的方法，可以重写重名的方法。
        • 如果继承父类的同时，也继承方法。它们都有同名的方法，默认继承父类方法。
    • 代码示例
      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
          package com.zzz.tel;
         // 接口访问修饰符：public 默认
          public interface INet {
       /*接口中抽象方法可以不写abstract关键字
         /*访问修饰符默认public
          * 当类实现接口时，需要去实现接口中的所有抽象方法，否则需要将该类设置为抽象类
          */
      void network();


      //接口中可以包含常量，默认public static final
      int TEMP=20;

         //default：默认方法 可以带方法体 jdk1.8后新增
      //可以在实现类中重写，并可以通过接口的引用调用
      default void connection(){
      	System.out.println("我是接口中的默认链接");
      }

      //static:静态方法 可以带方法体 jdk1.8后新增
      //不可以在实现类中重写，可以同接口名调用
      static void stop(){
      	System.out.println("我是接口中的静态方法");
      }
        }
  5. 内部类
    • 在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
    • 与之对应，包含内部类的类被称为外部类
    • 内部类隐藏在外部类之内，更好的实现了信息的隐藏。不允许其它类随意的访问。
    • 内部类分类
      • 1、成员内部类
        • 内部类中最常见的就是成员内部类，也称普通内部类
        • 1、内部类在外部使用时，无法直接实例化，需要借由外部类的信息才能完成实例化
        • 2、内部类的访问修饰符，可以任意，但是访问范围会受到影响
        • 3、内部类可以直接访问外部类的成员，如果出现同名属性，优先访问内部类中定义的
        • 4、可以使用 外部类.this.成员 的方式，访问外部类中同名的信息
        • 5、外部类访问内部类信息，需要通过内部类实例，无法直接访问
        • 6、内部类编译后 .class 文件命名：外部类$内部类.class
        • 内部类的获取方式
          • 1、new 外部类.new 内部类
          • 2、外部类对象.new 内部类
          • 3、外部类对象.获取方法
      • 2、静态内部类
        • 【成员共享】静态内部类对象可以不依赖于外部类对象，直接创建
        • 1、静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例
        • 2、静态内部类对象实例时，可以不依赖于外部类对象
        • 3、可以通过 外部类.内部类.静态成员 的方式，访问内部类中的静态成员
        • 4、当内部类属性与外部类属性同名时，默认直接调用内部类中的成员；如果需要访问外部类中的静态属性，则可以通过 外部类.属性 的方式；如果需要访问外部类中的非静态属性，则可以通过 new 外部类().属性 的方式；
      • 3、方法内部类
        • 定义在外部类方法中的内部类，也称局部类。
        • 1、定义在方法内，作用范围也在方法内
        • 2、和方法内部成员使用规则一样，class 前面不可以添加 public、private、protected、static
        • 3、类中不能包含静态成员
        • 4、类中可以包含 final、abstract 修饰的成员
      • 4、匿名内部类
        • 将类的定义与类的创建，放到一起完成
        • 1、匿名内部类没有类型名称、实例对象名称
        • 2、编译后的文件命名：外部类$数字.class
        • 3、无法使用 private、public、protected、abstract、static 修饰
        • 4、无法编写构造方法，可以添加代码块
        • 5、不能出现静态成员
        • 6、匿名内部类可以实现接口也可以继承父类，但是不可兼得
        • 适用场景
          • 1、只有到类的一个实例
          • 2、类在定义后马上用到
          • 3、给类命名并不会导致代码更容易被理解

发表于 更新于 分类于

继承

  1. 概念
    • 一种类与类之间的关系
    • 使用已存在的类定义作为基础建立新类
    • 新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但 不能选择性地继承父类
    • 满足 “A is a B”的关系就可以形成继承关系
    • 子类可以访问父类非私有成员
    • 父类不可以访问子类特有成员
  2. 方法重写
    • 语法规则
      • 在子类中定义，去重写父类的方法
      • 方法名相同，参数列表相同（参数顺序、个数、类型）
        • 方法名、参数列表都要与父类继承的方法相同
      • 访问修饰符
        • 允许改变，但是访问范围需要大于等于父类的访问范围
      • 与方法的参数名无关
      • 方法返回值
        • 当方法返回值是void 或基本数据类型时，必须相同；当返回值是引用类型时，可以是父类或其子类
      • 方法的返回值和访问修饰符是可以允许有变化的（有条件的）
    • 当子类重写父类方法后，子类对象调用的是重写后的方法。
    • super：父类对象的引用 super.父类方法名()
    • 父类的构造不允许被继承；不允许被重写，但是会影响子类的实例化过程
  3. 特点
    • 利于代码复用
    • 缩短开发周期
  4. 语法
    • 使用 extends 实现封装
    • 单一继承，只能有一个父类
    • 名词解释
      • 父类（基类）
      • 子类（派生类）
    • 继承后的初始化顺序
      • 父类静态成员 -> 子类静态成员 -> 父类对象构造 -> 子类对象构造
      • 访问修饰符不影响成员加载顺序，跟书写位置有关
  5. super
    • 代表父类引用
      • 访问父类成员方法
        • super.print();
      • 访问父类属性
        • super.name;
      • 访问父类构造方法
        • super()
    • 子类的构造的过程中必须调用其父类的构造方法
    • 如果子类的构造方法中没有显式标注，则系统默认调用父类无参的构造方法
    • 如果子类构造方法中既没有显式标注，且父类中没有无参的构造方法，则编译错误。
    • 子类构造默认调用父类无参构造方法，可以通过 super() 调用父类的允许被访问的其他构造方法，super() 必须放在子类构造函数有效代码的第一行。
    • 构造方法调用时，super 和 this 不能同时出现
  6. Object 类
    • 概念
      • Object 类是所有类的父类
      • 一个类没有使用 extends 关键字明确标识继承关系，则默认继承 Object 类（包括数组）
      • Java 中的每个类都可以使用 Object 中定义的方法
  7. final 关键字
    • final class
      • 该类没有子类
      • public final class | final public class 写法都行
    • final 方法
      • 该方法不允许被子类重写，但是可以正常被子类继承使用
    • final 变量
      • 方法内局部变量
        • 只要在具体使用之前进行赋值即可，一旦赋值不允许修改
      • 类中成员属性
        • 赋值过程
          • 定义的时候直接初始化
          • 构造方法中
          • 构造代码块
      • 基本数据类型的变量
        • 初始赋值之后不能更改
      • 引用类型的变量
        • 初始化之后不能再指向另一个对象，但对象的内容是可变的
    • final + static 定义后，在程序运行中不允许二次修改。
      • 可以修饰方法和变量
      • 修饰配置信息 public static final String URL = “www.xxx.com“
    • final 不允许加载构造方法前面
    • 使用 final 修饰可以提高性能，但会降低可扩展性
  8. 注解
    • JDK1.5 版本引入的一个特性
    • 可以声明在包、类、属性、方法、局部变量、方法参数等的前面，用来对这些元素进行说明、注释
    • 一种特殊的标记
    • 常用注解
      • @Override 针对父类方法进行重写的形式
    • 分类
      • 按照运行机制分
        • 源码注解
          • 注解只在源码阶段保留，在编译阶段会被丢弃。例如：@Overide
        • 编译时注解
          • 注解会在编译时期保留，在加载 class 文件时会被丢弃。例如：@NotNull
        • 运行时注解
          • 在运行阶段还起作用，甚至会影响运行逻辑的注解。@Autowired
      • 按照来源分
        • 来自 JDK 的注解
          • @Override
        • 来自第三方的注解
          • 框架的注解
        • 我们自定义的注解
      • 元注解
        • 对注解进行注解
          • 对注解进行标注
        • @Target 限定注解可以用在什么地方

访问修饰符

  1. 公有的 ：public
    • 允许在任意位置访问
  2. 私有的：private
    • 只允许在本类中进行访问
  3. 受保护的：protected
    • 允许在当前类、同包子类/非子类、跨包子类调用、跨包非子类不允许
  4. 默认
    • 允许在当前类、同包子类/非子类调用；跨包子类/非子类不允许调用

发表于 更新于 分类于

类和对象

  1. 面向对象
    • 关注现实存在的事物的各方面信息，从对象的角度出发，根据事物的特征进行程序设计
    • 对象：用来描述客观事物的一个实体
    • 类：具有相同属性和方法的一组对象的集合
  2. 属性
    • 对象具有的各种静态特征
    • “对象有什么”
  3. 方法
    • 对象具有的各种
    • “对象能做什么”
    • 在方法中通过对象作为参数，传递的是它的引用，可以通过引用获取该对象的所有信息。
  4. 类
    • 抽象的概念
    • 模板
    • 类是模子，确定对象将会拥有的特征（属性）和行为（方法）
    • 类是对象的类型
    • 构造方法
      • 注意事项
        • 构造方法与类同名且没有返回值（必须与类名相同）
          1
          2
          3
          4
          5
          // 构造方法的语法格式：
          // 没有返回值类型 , 构造方法名 与类名相同 
          public 构造方法名(){
            // 初始化代码
          }
        • 只能在对象实例化的时候调用
      • 特点
        • 当没有指定构造方法时，系统会自动添加无参的构造方法
        • 当有指定构造方法，无论是有参、无参的构造方法，都不会自动添加无参的构造方法
        • 一个类中可以有多个构造方法
        • this(); 访问其它无参或带参 构造方法
    • this 关键字
      • this：当前对象的默认引用
      • this 的使用
        • 调用成员属性，解决成员属性的局部变量同名冲突
        • 调用成员方法
        • 调用重载的构造方法 this();
          • 通过 this() 调用构造方法，必须放在方法体内的第一行！！！
  5. 对象
    • 基本概念
      • 一个看得到、摸着着的具体实体
      • 对象是类的实例表现
      • 万物皆对象
      • 对象是特定的类型数据
    • 对象实例化
      • 实例化对象过程可以分为两部分
        • 声明对象 Class 对象名称
          • 在内存的栈中开辟一个空间，此时栈空间的数据是空的
        • 实例化对象 new Class
          • 经过实例化的环节，会在内存的堆中开辟一块空间，在此完成具体属性赋值等相关操作
            声明对象和实例化对象通过 = 赋值符号完成。经过赋值操作，将内存的堆地址，传递到栈当中的内存空间里。
      • 内存分配 栈[局部变量] ，堆[动态数据]
    • 注意事项
      • 需要多次访问同一对象时，必须进行声明
      • 同一作用范围内，不能定义同名对象
      • 可以同时声明多个引用，用逗号分割
        1
        2
        3
        4
        Cat one,two;
        one = new Cat();
        two = new Cat();
        Cat three = new Cat();four = new Cat();

封装

  1. 将类的某些信息隐藏在类的内部，不允许外部程序直接访问，通过该类提供的方法来实现对隐藏信息的操作和访问
    • 隐藏对象的信息
    • 留出访问的接口
  2. 特点
    • 只能通过规定的方法访问数据
    • 隐藏类的实例细节，方便修改和实现
  3. 实现步骤
    • 1、修改属性的可见性 ，设为 private
    • 2、创建 getter/setter 方法 ，设为 public 用户属性的读写
    • 3、在 getter/setter 方法中加入属性控制语句，对属性的合法性进行判断
  4. 包（类似文件夹）
    • 作用
      • 管理 Java 文件
      • 解决同名文件冲突
    • 定义包
      • 语法 package 包名;例：package com.zje.animal;
      • 注意
        • 一个 Java 源文件只能有一个 package 语句，必须放在 Java 源文件中的第一行
        • 包名全部英文小写
        • 建议每个包内存储信息功能单一
        • 包命名规则：域名倒序+模块+功能
        • Java 中一个包不能存在同名类
    • 导入包
      • 语法 import 包名.类名;
      • 导入包中全部类 import com.xxx.*; 导入包中指定类 import com.xxx.animal.Cat;
    • 常用系统包
      • java.lang
        • 包含 Java 语言基础的类，该包系统加载时 默认导入。如 System、String、Math
      • java.util
        • 包含 Java 语言中常用工具。如 Scanner、Random
      • java.io
        • 包含输入、输出相关功能的类。如File、InputStream
    • 问题
      • 如何实现跨包的类调用？
        • 建议采用“import 包名.类名;” 的方式加载，提高效率
        • 加载类的顺序跟 import 导入语句的位置无关
        • “import 包名.*”; 无法访问指定包名下的类，无法访问子包下的类
      • 有几种调用形式？
        1. 使用 import 语句导入目标类:这种方式可以直接在代码中使用 TargetClass 而无需指定完整的包路径。
        import com.example.targetpackage.TargetClass;
        1. 使用完整的包路径访问目标类:这种方式需要在代码中完整地指定目标类的包路径。
        com.example.targetpackage.TargetClass targetObject = new com.example.targetpackage.TargetClass();
        1. 使用 static import 导入目标类的静态成员:这种方式可以直接访问目标类的静态成员,无需指定类名。
        import static com.example.targetpackage.TargetClass.staticMethod;
staticMethod(); // 直接调用静态方法
        1. 使用 default 访问修饰符允许同一个包下的类进行访问:这种方式需要将目标类的方法声明为 default 访问修饰符,这样同包下的其他类就可以访问该方法。
        // com.example.targetpackage.TargetClass
default void defaultMethod() {
  // 此方法可被同包下的其他类访问
}
  5. static 关键字
    • 1、类对象共享
    • 2、类加载时产生，销毁时释放，生命周期长
    • 注意事项
      • 在成员方法中，可以直接访问类中的静态成员
      • 静态方法中不能直接访问非静态成员，只能直接调用静态成员
      • 只能通过对象实例化后，对象.成员方法的方式访问非静态成员
      • 静态方法中不能使用 this
    • 静态成员访问方式
      • 1、对象.成员
      • 2、类.成员
  6. 代码块
    • 普通代码块：每此调用方法 顺序执行，先出现，先执行。
    • 构造代码块：在类中定义，创建对象时调用，优先于构造方法执行。可以有多个
    • 静态代码块
      • static { <语句> }
      • 类加载时调用，优先于构造代码块执行
      • 无论产生多少类实例，静态代码块只执行一次，构造代码块在每次对象构造的时候调用

成员属性的初始值

数据类型 默认值
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char ‘\u0000’
boolean false
引用类型对象的初始值 null

发表于 更新于 分类于

什么是方法？

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

方法的声明和调用

  1. 方法声明
    • 语法格式
      1
      2
      3
      访问修饰符 返回类型 方法名(参数列表){
        方法体
      }
    • 访问修饰符
      • public
      • privete
      • protected
      • 默认
    • 方法是在类的内部中定义
  2. 方法调用
    • 语法格式
      • 类名 实例名 = new 类名(); 实例名.方法名();
      • 对于静态方法 static , 直接调用 方法名();
  3. 方法分类
    • 根据方法是否带参数、是否返回值，可以分为四类：
    • 无参无返回值方法
    • 无参带返回值方法
    • 带参带返回值方法
    • 带参无返回值方法

方法重载

  1. 同一个类中
  2. 方法名相同，参数列表不同
  3. 方法返回值、访问修饰符任意
  4. 与方法参数名无关

可变参数列表

  1. public void sum(int… n) { <语句块> }
    1
    2
    3
    4
    5
    6
    7
    8
      	public void sum(int... n) {
    	
    	int sum =0;
    	for(int i:n) 
    		sum+=i;
    	
    	System.out.println("sum="+sum);
    }
  2. 参数列表中如果有两个以上的参数，可变参数一定是在最后的！
  3. 可以将数组传递给可变参数列表，反之不行
  4. 数组作为参数时，是不能将多个值传递给数组的！
  5. 一个方法中，只能有一个可变参数
  6. 可变参数列表所在的方法是最后被访问的。

方法的传值问题

  1. 基本数据类型传值
    • 方法中对参数的修改，不会对主方法传来的变量值产生影响
  2. 引用数据类型传值
    • 方法中对数组的改变，会印象主方法中传来的数组

访问修饰符

访问修饰符 本类 同包 子类 其他
private √
默认（不写） √ √
protected √ √ √
private √ √ √ √

发表于 更新于 分类于

什么是数组

  1. 数组是相同类型的数据按顺序组成的一种引用类型
  2. 数据类型
  • 基本数据类型
  • 引用数据类型
    • 类
    • 接口
    • 数组
    • 等等
  1. 注意的问题
  • 数组是引用数据类型
  • 创建数组时，会开辟连续的内存空间
  • 数据长度使用 length 属性获取
  • 数组元素的下标从0开始
  • 数组下标越界问题

一维数组

  1. 声明
  • 语法格式
    • 数据类型[] 数组名;
    • 数据类型 数组名[];
  • 变量声明的语法格式
    • 数据类型 变量名;
  1. 创建
    • 语法格式一：先声明后创建
      • 数据类型[] 数组名;
      • 数组名 = new 数据类型[数组长度];
      • int [] arr;arr = new int[10]; 创建一个长度为10的整型数组
    • 语法格式二：声明的同时创建数组
      • 数据类型[] 数组名 = new 数据类型[数组长度];
      • int [] arr = new int[10]; 创建长度为10的整型数组 arr
      • 注意：数组长度必须指定
    • 数组在内存中的存储
      • 数组会被分配连续的内存空间
      • 局部变量和数组的默认值问题
        • 局部变量没有默认值、数组有默认值（数组的本身是对象）
  2. 初始化
    • 声明数组的同时给数组赋值，叫做数组的初始化
    • int[] arr = {1,2,3,4,5}; 数组的长度就是初始化时所给数组元素的个数 (花括号)
  3. 元素的引用
    • 语法格式：数组名[下标]
    • 注意：下标从 0 开始
  4. 长度
    • arr.length 表示数组的长度

二维数组

  • 二维数组的声明和创建
    • 声明
      1
      2
      3
      int[][] intArray;
      float floatArray[][];
      double[] doubleArray[];
    • 创建 
      1
      intArray = new int[3][3]
      • 列可以省略，行不能省略 
        1
        floatArray = new float[3][]; floatArray[1] = new float[3];
  • 二维数组的初始化 
    1
    int[][] num = {{1,2,3},{4,5,6},{7,8,9}};
  • 二维数组的引用
  • 多个一维数组组成的内容

增强型 for 循环

  1. 又叫 foreach 循环
  2. foreach 循环引用
    1
    2
    3
    int[] arr = {1,2,3,4};
    for(int n;arr)
    System.out.println(n);

发表于 更新于 分类于

流程控制语句

  1. 三大流程控制语句：顺序、选择、循环
    • 顺序结构，从上往下依次执行
    • 选择结构，根据条件执行对应的内容
    • 循环结构，循环执行，反复执行

选择结构

  1. if 结构 ，if - else 结构
  2. 多重 if
  3. 嵌套 if
  4. switch 结构
  5. if 和 switch 的区别
    • if 结构
      • 判断条件是布尔类型
      • 判断条件是一个范围
    • switch 结构
      • 判断条件是常量值
        JDK 7.0 以后表达式的值可以是基本数据类型的，byte，short，int，char，以及 String 类型。

循环结构

  1. while
    • 如果循环体只有一条语句，大括号可以省略
    • 为避免死循环，小括号后面不要加分号
    • 语法格式 while(条件){ <语句> }
  2. do-while
    • 注意事项
      • do-while 循环至少执行一次
      • 循环条件后的分号不能丢
      • 局部变量使用前必须初始化
    • 语法格式 do{ <语句>} while(循环条件);
    • Math.random() 得到 [0,1) 之间的随机数
  3. for
    • 语法格式：for(表达式1;表达式2;表达式3){ <语句>}
    • 注意事项：break 语句表示跳出当前循环
  4. 循环嵌套
  5. break 语句
    • break 语句可以结束当前循环的执行
    • 执行完 break 语句后，循环体中位于 break 语句后面的语句就不会被执行
    • 在多重循环中，break 语句只向外跳一层
    • 注意：break 跳出当前循环
  6. continue 语句
    • continue 语句只能用在循环里
    • continue 语句可以结束当前循环的执行，但是要继续执行下一次循环的执行

发表于 更新于 分类于

表达式

  1. 表达式由运算符和操作数组成
  2. 如：5、num1、num1 + num2

运算符

  1. 算数运算符
    • 算数运算符主要用于进行基本的算数运算，如加法、减法、乘法和除法等。
    • 加法 +
    • 减法 -
    • 乘法 *
    • 除法 / 在除法运算中，如果除数和被除数都是整数，则做整除运算
    • 求余数 %
    • 自增1 ++
    • 自减1 –
  2. 赋值运算符
    • 格式：变量 = 表达式;
    • 注意：赋值运算符是从右往左运算！
    • 赋值运算符的左边不能是常量，必须是常量
    • 复合赋值运算符
      • += 代码示例：x+=5 , x = x + 5
      • -=
      • *=
      • /=
      • %=
  3. 关系运算符
    • 比较运算符用于判断两个数据的大小，如大于
    • 比较的结果是一个 布尔值
    • 大于 >
      • ‘A’ > ‘’B 结果为 false , 比较的是两个字符的 ASCll 值
    • 小于 <
    • 大于等于 >=
    • 小于等于 <=
    • 等于 ==
      • float f = 5.0f; long l =5; f==l; 结果为true，浮点数与整数进行比较，只要值相等就返回true
    • 不等于 !=
    • 作用与功能
      • 数据比较
        • 关系运算符主要用于条件和循环语句中的判断条件
        • 条件结构就是根据不同的条件去执行不同的操作
  4. 逻辑运算符
    • 逻辑运算符是用来连接一个或多个条件，判断这些条件是否成立
    • 逻辑运算符的结果是布尔类型
    • 与
      • && 或 &
        • && 运算符又叫短路运算符，如果第一个表达式的值就能决定表达式最后的结果，运算符右边的表达式就不再运算了
        • & 不论第一个表达式 true 还是 false，都要执行右边的表达式
      • operator1 && operator2
    • 或
      • || 或 |
        • || 和 && 运算符一样
        • | 和 & 一样
      • operator1 || operator2
    • 非
      • !
        • 对原条件进行取反
      • !operator1
    • 注意：逻辑运算符的操作数都是布尔类型的
  5. 条件运算符
    • 三元运算符 ? :
  6. Java 中的条件运算符是三目运算符
    • ++ 单目运算符
    • 双目运算符，需要对两个数进行操作 + - * /
    • 语法：布尔表达式 ? 表达式1 : 表达式2
    • 当布尔表达式的值为 true , 则返回表达式 1 的值，否则 返回表达式 2 的值
  7. 位运算符
    • 按位与（&）：逐位进行与操作，只有当对应位都为 1 时，结果位才为 1。 
      1
      2
      3
      int a = 5; // 二进制为 0101
      int b = 3; // 二进制为 0011
      int c = a & b; // 结果为 1 (二进制为 0001)
    • 按位或（|）：逐位进行或操作，只要有一个对应位为 1，结果位就为 1。 
      1
      2
      3
      int a = 5; // 二进制为 0101
      int b = 3; // 二进制为 0011
      int c = a | b; // 结果为 7 (二进制为 0111)
    • 按位异或（^）：逐位进行异或操作，当对应位不同时，结果位为 1。 
      1
      2
      3
      int a = 5; // 二进制为 0101
      int b = 3; // 二进制为 0011
      int c = a ^ b; // 结果为 6 (二进制为 0110)
    • 按位取反（~）：逐位进行取反操作，0 变 1，1 变 0。 
      1
      2
      int a = 5; // 二进制为 0101
      int b = ~a; // 结果为 -6 (二进制为 1010)
    • 左移（<<）：将二进制位向左移动指定的位数，相当于乘以 2 的指定次方。 
      1
      2
      int a = 5; // 二进制为 0101
      int b = a << 1; // 结果为 10 (二进制为 1010)
    • 右移（>>）：将二进制位向右移动指定的位数，相当于除以 2 的指定次方。 
      1
      2
      int a = 5; // 二进制为 0101
      int b = a >> 1; // 结果为 2 (二进制为 0010)
  8. 运算符优先级
    运算符 描述 权重
    () 圆括号 0
    !，++，– 逻辑非，自增，自减 1
    *，/，% 乘法，除法，取余 2
    +，- 加法，减法 3
    <，<=，>，>= 小于，小于等于，大于，大于等于 4
    ==，!= 等于，不等于 5
    && 逻辑与 6
    || 逻辑或 7
    =，+=，*=，/=，%=，-= 赋值运算符，复合赋值运算符 8
0%