读书笔记1

java 5 2016-02-29 13:03
女装

数据类型

整型

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

  • short 存储要求:2byte 取值范围:-32768 -- 32767

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

  • byte 存储要求:1byte 取值范围:-128 -- 127
    java没有任何无符号类型(unsigned)

浮点类型

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

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

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

  • float类型的数值有一个后缀F(如3.14F),没有后缀的浮点数值(如3.14)默认为double类型。当然也可以在浮点数值后添加后缀D表示double类型

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,shortint,以及它们包装类的常量表达式

  • 枚举常量

  • 字符串字面量(从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.utiljava.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:对本包和所有子类可见

  • 默认(不需要修饰符):对本包可见

女装
文章评论