DAY00--JAVA基本知识

首先要放一段经典代码：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello world!");
    }
}

JAVA基础知识

关键词:

类，对象，方法，属性，引用，变量，

java特性

• 简单性，与C++类似
• 面向对象
• 分布式
• 健壮性（消除了指针）
• 安全性
• 可移植性
• 解释型
• 高性能
• 多线程

jdk与jre有什么区别？

• jre，面向要运行java程序的用户，是java运行时环境，只要安装了jre则是可以运行java程序了
• jdk，面向java开发人员，是软件开发工具包，如果你需要编写java程序，则需要安装jdk
  • jdk包括jre，还包括了编译器javac，还包括了java程序分析和调试的工具

数据类型

• 基本数据类型：布尔类型，整型，浮点型，字符型
  • 其中整数类型有：byte,short,int,long类型(8,16,32,64)，换成字节则是1字节，2字节，4字节，8字节
    • 其中int大概是正负20亿左右，
    • java字符编码是用Unicode编码，
  • 浮点型：float,double (32,64)，4字节，8字节
    • 默认是double类型，除非你加了f，如 float f=12.3f;所以，为了节省空间，后面要加个f，
    • double是float精度的双倍
• 引用数据类型：即对象的引用，(相当于一个遥控器)

• main方法是java程序的起点，真正被执行的是类，类会被加载，
• boolean与integer是不相容的，所以

int x=1; while(x){}//是不行的

常量

• 常量值
  • 布尔值
  • 整数
  • 浮点数
  • 字符和字符串
• 自定义常量
  • public static final double PI = 3.14; final一般与static搭配使用
• 本地方法能够修改常量，如System类的setOut方法，理由是他不是用Java语言实现的

• main方法的两个用途
  • 在测试类
  • 启动应用程序
• java程序会让对象与对象进行交互，交互是指相互调用方法，
• java程序是由一组类构成，其中一个类有main方法

编译器

• 作用：判断程序是否可以通过编译，不能的话还要指出哪里需要修改，
• 注意：他可能比会人，更谨慎，如int a=24; byte b=a;会报错，因为编译器认为可能会有溢出的可能

注释

（这篇博客写的挺好，至少比书里好）

IDEA可以导出javadoc文件，

按照注释后面的元素分类，

• 类注释（分三段，每段以英文句号结束）其他同理
  • 概要描述：描述类的作用,@see,@link
  • 详细描述：详细描述类的作用
  • 文档标注：要来标注作者@author，创建时间@，参考文献等
• 域注释
• 方法注释
  • 概要描述：描述方法的作用
  • 详细描述：详细描述方法的作用
  • 文档标注：用于标注参数、返回值、异常、参阅等@return,@param,@throws,

程序员分：客户端程序员，与类开发者，对于JDK来说，我就是客户端程序员

引用：

没有被引用的对象将被垃圾回收器GC回收，引用数，对象数

为什么需要封装：因为不封装数据会暴露，通过封装能实现数据隐藏，

变量

• 声明变量：不仅要声明变量类型，还要声明变量名
• 初始化：即给变量赋值
• 给变量赋值的方法：字面值，或者是变量，字面值即：固定的值
• java是通过值传递的，也就是拷贝传递的，如果传递的是引用，传递的也是引用的拷贝，而不是对象的拷贝
• 如果要多个返回值的话，可以考虑返回数组类型，数组也是对象，是引用类型
• 实例变量与局部变量的区别：声明的位置不同：实例变量声明在类中，而局部变量声明在方法中，局部变量在使用前一定要先初始化，
• 基本类型可以通过来判断值是否相同，而也可以判断两个引用是否指向同一对象，而判断两个对象是否相等则是通过equals()方法，
  • 如果类没有覆盖equals方法，那么equals方法与==一样
  • 如果类覆盖了equals方法，则是看对象里面的内容是否相等
• 创建新类的过程：先写伪代码，然后是测试类，最后才是真实代码

变量类型（根据位置来分类）

• 分3类：静态变量（位于方法之外，用static修饰），实例变量（位于方法外，没有static修饰），局部变量（位于方法之内）

• 局部变量：在方法，构造方法，语句块内声明，执行完后被销毁，无默认值，在”栈“上分配

• 实例变量：在类中声明，在方法，构造方法，语句块之外，在对象创建时创建，在对象销毁时销毁，

  有默认值，整型为0，布尔类型为false,引用类型为NULL，

在创建数组的时候，会对元素进行初始化，如基本类型的boolean就会将元素初始化成false，而引用类型的则是默认元素值为null，
Boolean[] booleans=new Boolean[7];
System.out.println(Arrays.toString(booleans));//[null, null, null, null, null, null, null]

boolean[] booleans1=new boolean[7];
System.out.println(Arrays.toString(booleans1));//[false, false, false, false, false, false, false]

• 静态变量（也叫类变量）：
  • 位于静态存储区，很少单独使用static，
  • 一般都是声明为常量 public static final不管创建多少个对象，都只有一份静态变量，
  • 一般都是大写，大多数声明为public类型，
  • 通过类名.变量名访问

方法

• 方法定义：修饰符 返回值类型 方法名(形参1，形参2,…){}
• 类型后… 有什么用，其实就是起到接收不固定的实参个数，编译器会转换成一个数组的。
• 方法调用
• 方法重载：方法名相同，参数不同（参数个数、参数类型，参数顺序不同），优点：便于使用
  • 注意：返回值类型可以不同，但是不能只改返回值类型

public int addNums(int a,int b){return a+b;}
public double addNums(double a,double b){return a+b;}

• 方法递归：方法调用自身，但是必须有结束条件
• 方法继承

修饰符

• 访问修饰符

  • private 仅在同一个类内可以访问(不能修饰类)
  • default（缺省，即什么都不写）仅在同一个包内可以访问
  • protected 同一个包内的类可以访问，所有子类也可以访问(不能修饰类)
  • public则是所有类都可以访问

• 非访问修饰符

  • static用于修饰方法和变量
  • final用来修饰类，方法，和变量，final修饰的类不能被继承，final修饰的方法不能被重写，final修饰的变量为常量
  • abstract用来修饰类和方法
  • synchronized 和 volatile 修饰符，主要用于线程，synchronized 关键字声明的方法同一时间只能被一个线程访问。

运算符

• 算术运算符：+ - * / ,%,++ –
• 赋值运算符：+= ,-=, *=, /=, %=,<<=, >>=,&=,|=,^=，
• 关系运算符：== ,!=,>,>=,<,<=,
  • == 与!=不仅仅适用于基本数据类型，也适用于所有对象，但是对象使用 == 来判断只能是比较引用，而非比较对象的内容，如果要比较对象内容，你只能用equals方法，
• 位运算符：&,|,~,^,<<,>>
  • 按位运算符可以与=联合使用，如&=
  • >> 与>>>的区别，，都是要先转换成2进制，然后右移，不同的是>>是左边或一律补0或一律补符号位（在使用补码作为机器数的机器中，正数的符号位为0，负数的符号位为1），而>>>则是左边一律补0，
• 逻辑运算符：&&,||,!
  • 其中&&是短路与
• 其他运算符：? : ，instance of 判断对象是否是某一特定类型

控制执行流程

if-else

循环结构 for,foreach,while, do…while,

• do…while则是至少执行一次

• 其中增强for循环，运用于数组，和任何Iterable对象

• break是跳出本层循环，而continue则是跳出本次循环，进入下一次循环，

选择语句switch case

作用：用于判断变量与一系列值中的某个值是否相等

• case里面支持的类型：整型，字符型，还有String
• 最后一个default分支不需要break语句
• 与枚举类型搭配

return的作用

• 指定一个方法返回什么值
• 导致当前方法退出

初始化和清理

初始化和清理都是涉及到安全的两个话题

为什么需要初始化？

• 使用对象之前，要确保这个对象会得到初始化，所以，我们采用构造器来确保初始化

重载

为什么需要方法重载？

• 方法重载的这种需求最初来源于我们需要以多种方式创建对象，但是构造器必须与类名同名，所以我们就需要至少2个同名同名的构造器，下面观点论证了方法重载的必要性

• 通常情况下我们不需要对所执行的动作进行明确的区分，如同样是洗，你通常会说"洗衬衫，洗车"，而不会说以”洗衬衫的方式洗衬衫，以洗车的方式洗车“，

怎样重载？

• 方法名相同，参数列表不同

重载规则

• 形参类型要比实参“大”，否则要将实现执行宅化转换，如传入一个double类型的，而只有float类型的形参，则是要进行(float)x强制类型转换

this关键字

为什么要有this关键字？

• 编译器会将”操作对象的引用“作为第一个参数传递给方法，但是没有标识符可用，所以用this来代表当前对象，即this=引用的值，然后用this来操作

this关键字加参数列表就可以调用构造器，而且为了减少冗余，可以在当前构造器调用另一个构造器

默认构造器（也叫无参构造器）

• 自己有写构造器，编译器就不会帮我们生成默认构造器

Static方法

static方法就是没有this（代表当前对象）的方法，所以你不能直接调用非静态方法，（当然，你可以创建另一个对象去调用）相反，非静态方法可以直接调用静态方法

构造器初始化

• 局部变量：
  • 如果没有初始化然后使用，编译器认为是你是疏忽，不会帮你设置一个默认值，设置了默认值反而掩盖了疏忽，所以，未初始化会报错，即强制初始化
• 类的实例变量与静态变量，则是会自动初始化，有默认值，
  • char为0，显示为空
  • byte,short,int,long为0
  • float,double为0.0
  • reference则是为null
• 初始化顺序
  • 实例变量声明的先后决定了初始化的先后，但是他们都会在任何方法（包括构造器）调用前得到初始化
  • 父类静态变量/静态代码块》子类静态变量/静态代码块》父类实例变量或普通代码块》父类构造器》子类实例变量或普通代码块》子类构造器，口诀就是：静态变量或者是静态代码块最先，然后是实例变量或普通代码块优先于构造器，基类先于子类

// Sup.java
public class Sup {

    private Object sup = new SupAssist();

    {
        System.out.println("sup non-static block");
    }

    public static Object sup1 = new SupStaticAssist();

    static {
        System.out.println("sup static block");
    }
    public Sup() {
        System.out.println("sup constructor");
    }
}

class SupAssist {
    public SupAssist() {
        System.out.println("sup assist variable");
    }
}

class SupStaticAssist {
    public SupStaticAssist() {
        System.out.println("sup static assist variable");
    }
}

//Sub.java
public class Sub extends Sup{
    static {
        System.out.println("sub static block");
    }

    {
        System.out.println("sub non-static block");
    }
    private Object sub=new SubAssist();
    public static Object sub1=new SubStaticAssist();

    public Sub() {
        System.out.println("sub constructor");
    }

    public static void main(String[] args) {
        new Sub();
    }
}

class SubAssist {
    public SubAssist() {
        System.out.println("sub assist variable");
    }
}

class SubStaticAssist {
    public SubStaticAssist() {
        System.out.println("sub static assist variable");
    }
}

• 显示初始化
  • 只执行一次：static{…}
• 非静态初始化
  • {…}

数组初始化

• 声明一个数组，方括号可在类型后面，也可在变量后面，int[] a或int a[]
• 基本类型数组
  • 如果不知道数组长度就先创建一个空数组吧，int[] arr;
• 对象数组

Integer[] a = {
    new Integer(1),
    new Integer(2),
    3//autoBoxing
};
//第二种更实用，不仅可以用在定义，还可以作为参数传递
Integer[] b = new Integer[]{
    new Integer(1),
    new Integer(2),
    3//autoBoxing
};

• 可变参数列表
  • Object… args，最终结果也是转换成数组，而且你实参不用显示的声明数组了，传参数列表就行
  • 可变参数列表让重载变得不安全，所以，你最好重载方法中只有一个版本使用可变参数列表

public static void printArray(Object... o) {
    for (Object o1 : o) {
        System.out.print(o1);
    }
    System.out.println();
}
public static void main(String[] args) {
    printArray(1,2,3,4);
    printArray(new Integer(1),new Integer(2),new Integer(3));
    printArray(new Integer[]{1,2,3});//直接传数组也行
}

枚举类型

为什么需要枚举？

• 我们需要一个常量集，且安全

枚举的优势

• 我觉得可以把枚举类型与常量类作比较来理解枚举的优势

枚举的使用

enum Spiciness {
    NOT,MILD,MEDIUM,HOT,FLAMING
}

public static void main(String[] args) {
    Spiciness s=Spiciness.FLAMING;
    System.out.println(s);
    for (Spiciness s1 : Spiciness.values()) {
        System.out.println(s1+",ordinal "+s1.ordinal());
    }
}

枚举可以与switch搭配，而且在switch中不需要使用类名。

构造器和垃圾回收器

对象有生有死，即对象有生命周期

关键词：栈，堆，范围，构造器

• 方法调用和变量生存空间：栈，其中变量是指局部变量，实例变量则是生存在对象中，

• 对象生存空间：堆

调用一个方法，那么这个方法就会被堆到栈顶，只有这个方法被执行完才会被释放掉（局部变量也会被释放掉）

为什么要知道栈和堆的机制？对以下知识点的理解很有用

• 变量的有效范围
• 对象的建立
• 内存管理
• 线程和异常处理

类和对象

类

• 描述对象的属性和行为，（即会有什么，会怎么做，如 会有名字，人会跑步）

• 对象

  • 拥有属性和行为，（即具体有什么，具体会怎么做，如具体名字是什么）

• 方法

  • 即行为

• 类之间常用的关系：依赖，聚合，继承

  • 依赖uses-a，其中一个类的方法操作了另一个类的对象，如order对象需要用到Account对象来查看信用等级，不负责销毁，两者生命周期不同
  • 聚合has-a，则是部分与整体的关系，如order对象中包括了Item(商品)对象，两者生命周期一样
  • 继承is-a，则是一般与特殊的关系，具有较高的耦合度

• JAVA命名特点

  • 大小写敏感
  • 类名：每个单词首字母都应该大写如Student
  • 方法名：以一个小写字母开头，每个单词首字母也是大写，驼峰式getName()
  • 常量：全部大写，如PI，

构造器

• 构造器与类同名，无返回值
• 每个类至少有一个构造器
• 构造器调用总是伴随着new操作

对象

• 对象的三大特征：行为，状态（即属性），标识

• 创建对象的方法

  • 通过new 指令
  • 通过反序列化
  • 通过反射
  • 通过clone

• 对象的创建过程：声明引用-》创建对象-》连接对象与引用，

方法

• 拥有基于类的访问权限，在类内部：方法可以直接访问所在类的私有属性，就算是在别的对象，但是只要是同一个类就行。
• 有public和private方法

什么是不可变类？什么是可变类？取决于有没有set方法

• 如String是不可变类，而StringBuilder是可变类