Java笔记02 - 面向对象编程

面向对象基础

  • class和instance是模板和实例的关系
  • class定义的field, 在每个instance中都会含有独立的field
  • 指向instance的变量, 都是引用变量

方法

  • field的修饰符, 由public改为private后, 不可直接访问, 需要通过method进行访问
修饰符 方法返回类型 方法名(方法参数列表) {
  若干方法语句;
  return 方法返回值
}
  • private方法只允许内部调用

this

  • 始终指向当前实例
  • 如果没有命名冲突可以省略this, 如果有局部优先级更高

方法参数

  • 调用方法时, 必须按照参数规则一一传递
  • 使用...进行可变参数
  • 如果0个参数时, 实际接收的是一个空数组
  • 基本类型参数的传递是调用值的复制
  • 引用类型参数的传递是指针的复制, 改变外边的值会影响到内部值
public class Hello {
    public String name;
    public int age;
    public static void main(String[] args) {
      City bj = new City();
      String n = "aaaaaa";
      bj.setName(n);
      n = "bbbbbb"; // 这里是新开了内存地址, 并不影响指针指向地震
      System.out.println(bj.getName()); // aaaaa
    }
};

class City {
    public String name;
    public String getName () {
      return this.name;
    }
    public void setName(String name) {
      this.name = name;
    }
}

构造方法

  • 方法名就是类型, 没有返回值
  • 构造方法没有参数限制
  • 内部可以执行任意语句
public class Hello {
    public String name;
    public int age;
    public static void main(String[] args) {
      City bj = new City("beijing");
      City wh = new City();
      System.out.println(bj.getName()); // aaaaa
      System.out.println(wh.getName());
    }
  };

  class City {
    public String name;
    public City() {
    }
    public City(String name) {
      this.name = name;
    }
    public String getName() {
      return this.name;
    }
    public void setName(String name) {
      this.name = name;
    }
}
  • 可以根据不同参数, 执行不同构造函数
  • 引用类型默认参数null, 数值类型int默认参数0, 布尔类型默认值false
  • 使用this(...)可以调用其他构成方法

方法重载

  • 同名不同参方法, 称为重载

继承

  • 使用extend来实现继承

继承树

  • 没有写extend默认继承自Object
  • 子类无法访问父类的private的字段和方法

protected

  • 子类可以访问父类的protected的字段和方法
  • protected修饰符, 把访问权限控制在继承树内

super

  • super表示父类
  • 在构造函数中, 需要添加super()
  • 子类不会继承任何父类的构造方法

向上转型

  • Person p = new Student();
  • 可以向上转型, 转化为更高层次

向下转型

Person p1 = new Student();
if (p1 instanceof Student) Student s = (Student) p1;

区分继承和组合

class Student extends Person {
    protected Book book;
    protected int score;
}

多态

  • 方法名相同, 参数或者返回值不同是, Overload写一个新方法
  • 如果全部相同(方法名, 参数, 返回值), 就是覆写Override
  • @Override用来检查覆写是否成功
  • Java中的方法调用是基于在实际运行时的方法调用, 而非变量的声明类型
  • 如果再子类中需要调用父类 使用super进行调用
  • final标记的方法不允许被重写
final class Person {
}

class Student extends Person { // The type Student cannot subclass the final class Person
}
  • final修饰的类, 不能被继承
  • final修饰的字段, 初始化后, 不能改变

抽象类

  • 如果仅仅是为了让子类覆写, 定义抽象方法 abstract.
abstract class Person {
  public abstract void run();
}
  • 只有抽象类才能有抽象方法
  • 抽象类无法被实例化
  • 子类必须完全覆写所有的抽象方法

接口

  • 只有抽象方法的抽象类, 可以更改为interface
  • 接口没有字段, 至于抽象方法, 全部默认为public abstract
class Student implements Person, Hello { // 实现了两个interface
    ...
}
  • 一个类可以继承多个接口
  • 接口可以继承接口
  • default方法, 可以不用所有子类都继承

public class Hello {
  public String name;
  public int age;
  public static void main(String[] args) {
    Person a = new Student();
    a.run();
  }
};

class Man {
}

interface Person {
  String getName();
  default void run() {
    getName();
  }
}

class Student extends Man implements Person {
  @Override
  public String getName() {
    System.out.print("aaa");
    return "aaa";
  }
}
  • 通过default, 可以给接口添加方法, 而不用所有子类都添加方法

总结

  • 所有公共逻辑放到abstract class中, 具体实现在子类.
  • 接口表示更高层次的抽象程度.
  • 可以通过先继承, 再使用一个接口, 使用的时候用接口引用, 因为接口比抽象类更抽象

静态字段和静态方法

  • 静态字段共享一个空间
  • 调用实例方法, 必须通过一个实例, 但是静态方法就不用
  • 静态方法属于类, 没有this关键字
  • 静态方法, 经常用于工具类
  • 抽象类的静态字段, 必须是final

包

  • 命名空间, 用包(package)名, 进行区分
  • 包没有继承关系, java.util和java.util.zip是不同的包，两者没有任何继承关系。
  • 注意包的安放目录.

包作用域

  • 位于同一个包作用域的类, 可以访问作用域的字段和方法
  • 不用public, protected, private修饰的字段和方法就是包作用域
  • 包机制就是为了避免命名冲突

作用域

  • 定义public的class, interface可以被其他类任意访问
  • 定义public的field, method可以被其他类访问, 前提是可以访问到这个类
  • 定义private的field, method无非被其他类访问
  • 嵌套类可以访问private
  • 定义protected的field, method可以被子类访问, 以及子类的子类
  • 包作用域是指一个类允许访问同一个package中没有public, private修饰的class, 以及没有public, private与protected修饰的field, method

final

  • final与访问权限不冲突
  • 修饰class阻止被继承
  • 修饰method阻止子类被覆写
  • 修饰field阻止字段被重写
  • 修饰局部变量阻止被重写

最佳实践

  • 尽量不要public, 少暴露字段和方法
  • 方法定义为package权限, 有助于测试
  • 一个.java文件只能包含一个public, 并文件名和public类的名称一致

classpath和jar

  • 用来指示JVM如何搜索class
  • 没有传入的环境变量, 默认为.
  • 不需要把Java核心类库添加到classpath中!

jar 包

  • 如果要执行一个jar中的class中, 就把jar的目录放到classpath中

模块

  • jar是存放class的容器, 并不关心class之间的依赖关系
  • 自带"依赖关系"的class容器, 就是模块
  • java.base是根模块

JAVA核心类

字符串和编码

  • String
    • 保持绝对的不变性
    • 引用类型, class, 特殊, 可以用"..."表示
    • 内部使用char[]实现
  • 字符串比较
    • equals()进行比较
    • 编译期把所有相同字符串当做一个对象放入常量池
    • CharSequence是String的父类
    • 搜索: indexOf lastIndexOf startsWidth endsWidth
    • 提取: substring(2), substring(2, 4)
  • 去除首位
    • trim, strip
    • isEmpty, isBlank
  • 替换
    • replace
    • replaceAll
  • 分割字符串: split
  • 拼接: join
  • 类型替换
    • 任意类型 => 字符串: valueOf()
    • Integer.parseInt()
    • Boolean.parseBoolean()
    • String 和 char[] 类型可以互相转换
    • 为了保证不变形, 我们需要复制, 而不是直接引用
  • 编码
    • Java的String和char在内存中总是以Unicode
    • 转换编码就是String和byte[]转换
    • 转换byte[]时, 始终优先考虑UTF-8

StringBuilder

  • 可变对象, 可以预分配缓冲区, 这样新增字符时, 不会创建新的临时对象
  • 可以进行链式操作
  • java编译器进行编译时就自动把多个连续的+操作编码为StringConcatFactory的操作, 自动进行+操作的优化
  • StringBuffer是早期的一个线程安全版本, 同步保证多个线程, 但是同步会带来执行速度下降

StringJoiner

  • 高效拼接字符串, 使用StringBuilder

包装类型

  • 基本类型: byte, short, int, long, boolean, float, double, char
  • 引用类型: class, interface
  • 基本类型不能赋值为null
  • 每种类型都有对应的引用类型: Boolean, Byte, Short, Integer, Long, Float, Double, Character
  • Auto Boxing
    • Java自动帮我们编译
  • 不变类
    • 两个Integer对比, 应该是equals()进行对比
    • 静态工厂方法: 创建新对象的静态方法. 例如: Integer.valueOf()
  • 进制转换:
    • Integer.parseInt("100", 16)
    • Integer.String(100, 16)
    • Integer.toHexString(n): 自动把整数转坏为十六进制
  • 计算机中, 都是二进制存储, 数据的显示和存储要分离
  • 处理无符号整型: Byte.toUnsignedInt()
    • 带有符号-126 -> 127
    • 无符号0 -> 255
    • short无符号->int; int无符号->long

JavaBean

  • 有读有写: 属性
  • 只读不写: 只读属性
  • Introspector可以枚举JavaBean的所有属性

enum

  • 编译器自动检查某个值在枚举的集合内, 并且, 不同用途的枚举需要不同的类型类来标记
  • 比较: 直接用==
  • 和其他class没有任何区别
  • 方法:
    • .name(): 返回常量名
    • .ordinal(): 返回常量顺序
  • 可以给每个枚举常量添加字段
  • 每一个枚举类型所代表的属性都是一个实例
  • 使用toString变得更加具有输出性
  • 天生配合switch, 记得加上default
enum Weekday {
  SUN(0, "星期日"), MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六");
  public final int dayValue;
  public final String chinese;
  private Weekday(int dayValue, String chinese) {
    this.dayValue = dayValue;
    this.chinese = chinese;
  }
  @Override
  public String toString() {
    return this.chinese;
  }
}

BigInteger

  • 运算时只能用实例方法
  • 可以和long相互转换, 超过范围报异常.
  • 转换方法: byteValue, shortValue, intValue, longValue等
  • 转变float超范围, 返回: Infinity
  • .longValueExact保证转换正确性

BigDecimal

  • 表示任意大小, 且精度完全准确的浮点数
  • 使用`.scale()
    • 表示小数的位数
    • 如果返回负数, 表示是个整数, 并且末尾有几个0
  • .stripTrailingZeros()去除小数位的0
  • .setScale(位数, 截断方式): 按照指定位数进行截断
  • 除不尽的时候, 就需要进行一个截断
  BigDecimal d1 = new BigDecimal("123.456");
  BigDecimal d2 = new BigDecimal("23.1123");
  BigDecimal d3 = d1.divide(d2, 2, RoundingMode.HALF_UP);
  • divideAndRemainder(): 获得商和余数
  • compareTo(): 进行比较
    • 比较的时候, 不但要求值相等, 小数位数也相等
    • 根据大小返回. 负数, 整数, 0
  • 也从Number继承, 并不可变

常用工具类

  • Math: 数学工具
    • abs(), max()...
    • .PI
    • Math.random(): 0 <= x < 1
    • StrictMath: 保证各个平台计算结果一致
    • Math: 针对各个平台优化速度
  • Random: 创建伪随机数
    • .nextInt(): 随机数
    • .nextInt(10): [0, 10]之间的int
    • 不指定种子会把当前时间戳作为种子
    • 种子相同, 随机数序列相同
  • SecureRandom: 获得不可预测的安全随机数
    • 不同的底层实现
    • 种子通过CPU等各种随机事件产生

疑问

关于环境变量啥的, 该怎么区分

  • /System/Library/Frameworks/JavaVM.framework/Versions/Current/Commands/java_home
  • /Library/Java/JavaVirtualMachines/jdk-13.0.2.jdk/Contents/Home
  • 放弃了, 始终没有找到jmod这个命令在哪

语法

  • double y = 10.1; long n = (long) y
  • sr = new SecureRandom; sr.nextBytes(buffer)
posted @ 2020-03-11 11:51  张润昊  阅读(242)  评论(0)    收藏  举报