读书笔记1

时间  2019-12-05
标签 读书 笔记 繁體版
原文   原文链接

数据类型

整型

  • int 存储要求：4byte 取值范围：-2147483648 -- 2147483647(超过20亿)java

  • short 存储要求：2byte 取值范围：-32768 -- 32767面试

  • long 存储要求：8byte 取值范围：-9223372036854775808 -- 9223372036854775807sql

  • byte 存储要求：1byte 取值范围：-128 -- 127
    java没有任何无符号类型（unsigned） segmentfault

浮点类型

  • float 存储要求：4byte 取值范围：大约+-3.40282347E+38F(有效位数为6~7位)数组

  • double 存储要求：8byte 取值范围：大约+-1.79769313486231570E+308(有效位数为15位)this

  • double类型的精度是float的两倍spa

  • float类型的数值有一个后缀F(如3.14F),没有后缀的浮点数值（如3.14）默认为double类型。固然也能够在浮点数值后添加后缀D表示double类型code

char类型

char用于表示单个字符，一般用来表示字符常量对象

boolean类型

值true,false,用来断定逻辑条件。 整型值和布尔值之间不能进行转换 继承

变量

变量名必须是一个以字母开头的由字母或数字构成的序列，可是+,@这样的符号不能出如今变量名中，空格也不行。变量名的长度没有限制。另外，不能将变量命名为java的保留字。能够在一行中声明多个变量，如int i,j;

变量初始化

声明一个变量后，必须用赋值语句对变量进行显式初始化，千万不要使用未被初始化的变量，如

int a;
System.out.println(a);//ERROR--variable not initialized

常量

利用关键字final表示，这个变量只能被赋值一次，一旦被赋值，就不能再更改了。习惯上，常量名使用全大写。
类常量用关键字static final表示

运算符

算是运算符+,-,*,/分别表示加，减，乘，除。当参与/的两个数都是整数时，表示整数除法，不然表示浮点除法。%表示求余操做。

x+=4;
x=x+4;

二者等价。

数值类型间的转换

图片描述
实心箭头表示无信息丢失的转换，虚线箭头表示可能有精度损失的转换。
若是试图将一个数值从一种类型强制转换为另外一种类型，而又超过了目标类型的取值范围，结果会截断成一个彻底不一样的值

字符串

将一个字符串与一个非字符串的值进行拼接(+)时，后者会被转换成字符串，由于任何一个java对象均可以转换成字符串.

控制流程

块做用域

块是由一对花括号括起来的若干简单的java语句,块肯定了变量的做用域,一个块能够嵌套到另外一个块中。

public static void main(String[] args)
{
    int n;
    ...
    {
        int k;
        ...
    }//变量k的做用域到这里为止
}

可是，不能在嵌套的两个块中声明相同名字的变量

public static void main(String[] args)
{
    int n;
    ...
    {
        int n;
        int k;
        ...
    }//这里不能再定义变量n了
}

for循环

  • 在循环中，检测两个浮点数是否相等须要当心

for(double x=0;x!=10;x+=0.1)...

  • 在for语句中声明的变量，做用域是for循环的整个循环体

for(int i=0;i<10;i++){
    ...
}//i的做用域到此为止

若是想在循环体外使用i,就要确保i在循环语句的前面且在外部声明过

int i;
for(i=0;i<10;i++){
    ...
}
//循环体外面还可使用i

  • 能够在各自独立的不一样for循环中定义同名变量

for(int i=0;i<10;i++){
    ...
}
...
for(int i=10;i<20;i++){
    ...
}

switch语句

switch(choice){
    case 1:
        ...
        break;
    ...
    default:
        ...
        break;
}

case标签能够是

  • 类型为char,byte,short或int,以及它们包装类的常量表达式

  • 枚举常量

  • 字符串字面量(从java7开始)，如

switch(inputString){
    case "yes":
        ...
        break;
    ...
}

大数值

若是基本的整数和浮点数精度不能知足要求，可使用java.math包中的BigInteger,BigDecimal.这两个类能够处理包含任意长度数字序列的数值。BigInteger实现了任意精度的整数运算，BigDecimal类实现了任意精度的浮点数运算。
使用静态的valueOf方法能够将普通的数值转换为大数值。

BigInteger a=BigInteger.valueOf(100);

大数值间的运算须要使用大数值类中的方法，而不能算术运算符。

数组

声明数组int[] a;,实例化int[] a=new int[100];,这里建立了一个能够存储100个整数的数组，里面的全部元素都仍是初始化状态(值为0)。
对象数组的元素则初始化为null,表示这些元素还没存听任何对象
一旦建立了数组，就不能再改变它的大小(尽管能够改变每一个数组元素)
数组其余初始化方式int[] a={1,2,...};，int[] a=new int[]{1,2,...};

方法参数

  • 按值调用：方法接收的是调用者提供的值

  • 按引用调用：方法接收的是调用者提供的变量地址

java老是采用按值调用，也就是说，方法获得的是全部参数值的一个拷贝，结果就是方法不能修改传递给它的任何参数变量。
可是方法参数有两种类型
1.基本数据类型(int,boolean,...)
2.对象引用
对象引用做为参数能够经过调用对象里的方法改变对象里的类变量,可是这并不说明java的方法参数是对象引用

public class Employer {
    String name=null;
    Employer(String name){
        this.name=name;
    }
    static void swap(Employer a,Employer b){
        Employer temp=a;
        a=b;
        b=temp;
    }
    void print(){
        System.out.println(this.name);
    }
    public static void main(String[] args){
        Employer employer1=new Employer("aaa");
        Employer employer2=new Employer("bbb");
        swap(employer1,employer2);
        employer1.print();//aaa
        employer2.print();//bbb
    }
}

能够看到，尽管swap方法将两个Emplyer实例交换，但实际上交换的仅仅是两个对象引用的拷贝.

对象构造

调用另外一个构造器

若是构造器的第一行语句形如this(...),这个构造器将调用同一类的另外一个构造器。

public class TestCons {
    String name;
    public TestCons(){
        this("default1");
        //this.name="default";
    }
    public TestCons(String name){
        this.name=name;
    }
    public static void main(String[] args){
        TestCons testCons=new TestCons();
        System.out.println(testCons.name);//default1
    }
}

初始化块

在一个类的声明中，能够包含多个代码块，只要构造类的对象，这些块就会被执行。
具体参见一道面试题引起的思考:(1),文章说的很详细。

对象析构与finalize方法

java有自动的垃圾回收器，不须要人工回收内存，因此java不支持析构器。
finalize方法在垃圾回收器清除对象前调用。实际应用中，不要依赖于使用finalize方法回收任何短缺资源，由于很难知道这个方法何时调用。
若是某个资源须要在使用完毕后马上被关闭，就须要由人来管理。对象使用完，能够用close方法（若是有）完成相应的清理操做。

包

类的导入

只能使用(*)导入一个包，而不能使用import java.*或import java.*.*导入以java为前缀的全部包。
大多数时候，只导入所需的包就能够了。但发生命名冲突的时候，就须要变成具体的包名。例如
java.util和java.sql包里都有Date类

import java.util.*;
import java.sql.*;
...
Date today;//ERROR!--java.util.Date or java.sql.Date?
...

静态导入

import static java.lang.System.*;
...
out.println("gwegwe");//不用加类名前缀
exit(0);

警告
编译器在编译源文件时，不检查目录结构。
package com.theviper;,即便源文件没有在目录com\theviper下，也能够编译。若是它不依赖于其余包，就不会出现编译错误。可是最终的程序将没法运行，由于虚拟机找不到类文件

继承

使用super调用构造器的语句必须是子类构造器的第一条语句。
若是子类构造器没有显式调用超类构造器，则将自动调用超类默认(没有参数)的构造器。
若是子类没有不带参数的构造器，而且在子类构造器中没有显式调用超类的其余构造器，则编译器将报错。
super关键字做用

  1. 调用超类方法

  2. 调用超类构造器

this关键字做用

  1. 引用隐式参数(如this.name=name)

  2. 调用该类的其余构造器
    在覆盖一个方法时，子类方法可见性不能低于超类方法

阻止继承：final类和方法

目的：确保它们不会在子类中改变语义。
类变量也能够被声明为final,可是构造对象后就不容许再改变类变量的值了。

public class Parent {
    final String name="aaa";
    void setName(String name){
        this.name=name;
    }
    public static void main(String[] args){
        Parent parent=new Parent();
        parent.setName("bbb");//The final field Parent.name cannot be assigned
    }
}

可是若是将一个类声明为final,后面能够改变类变量的值了。

public final class Parent {
    String name="aaa";
    public static void main(String[] args){
        Parent parent=new Parent();
        parent.name="bbb";
        System.out.println(parent.name);//bbb
    }
}

抽象类

  • 类即便不含抽象方法，也能够声明为抽象类

  • 抽象类不能被实例化，但能够建立抽象类的具体子类对象

  • 能够定义抽象类的对象变量，但只能引用非抽象子类的对象。

AbstractClass a=new AbstractConcrete();

访问修饰符

  • private:仅对本类可见

  • public:对全部类可见

  • protected:对本包和全部子类可见

  • 默认（不须要修饰符）：对本包可见

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程