java中 new对象的括号里面有参数 java括号里面new是什么意思

学习Java一个多月了，对之前的内容做一下复习。
以下内容参考了《Java编程思想 第四版》 和《疯狂Java 第二版》 的内容。

1.用引用操纵对象

• 一切都被视为对象，但操纵的标识符实际上是对象的一个“”引用“”（reference）。如 String s; 这里所创建的只是引用，并不是对象。

2.必须由你创建所有对象

• 一旦创建了一个引用，就希望他能与一个新的对象相关联。new关键字的意思是“”给我一个新对象“”。
• String s = new String("asdf");

3.基本数据类型

基本类型	大小	默认值	包装器类型
boolean		false	Boolean
char	16-bit	‘\u0000’	Character
byte	8 bits	(byte)0	Byte
short	16 bits	(short)0	Short
int	32 bits	0	Integer
long	64 bits	0L	Long
float	32 bits	0.0F	Float
double	64 bits	0.0D	Double

4.引用数据类型

• 类，数组，接口 默认值为：null

5.作用域

• 作用域决定了在其内定义的变量名的可见性和生命周期，作用域由花括号的位置决定。如：

{
    int x = 10;
    //x可见
    {
        int y =5;
        //x , y 都可见 
    }
    //x 可见  ，  y不可见
}

6.标识符和关键字

分号 ;
分号作为语句的分隔。每个Java语句必须使用分号作为结尾。
花括号 {}
花括号的作用就是定义一个代码块。
方括号 []
方括号的主要作用是用于访问数组元素，方括号通常紧跟数组变量名，而方括号里指定希望访问的数组元素的索引。
圆括号（）
定义方法时必须使用圆括号来包含所有的形参声明，调用方法时也必须使用圆括号来传入实参值。
圆括号还可以作为强制类型转换的运算符。
圆括号可以将表达式某个部分括成一个整体，保证这个部分优先计算。
空格
Java语言使用空格分隔一条语句的不同部分。
圆点
通常用作类/对象和它的成员之间的分隔符，表明调用某个类或某个实例的指定成员。

标识符规则

• 标识符可以由字母、数字、下划线、和美元符（$）组成，其中数字不能打头。
• 标识符不能是Java关键字和保留字，但可以包含关键字和保留字。
• 标识符不能包含空格。
• 标识符只能包含美元符，不能包含@#等其他特殊字符。

Java关键字

• Java语言中一些具有特殊用途的单词被称为关键字，所有的关键字都是小写的。

1	2	3	4	5	6
abstract	assert	boolean	break	byte	case
catch	char	class	continue	default	do
double	else	enum	extends	final	finally
float	for	if	implements	import	int
interface	instanceof	long	native	new	package
private	protected	public	return	short	static
strictfp	super	switch	synchronized	this	throw
throws	transient	try	void	volatile	while

7.运算符

算术运算符

• Java支持所有的基本算术运算符：
• +：加法运算符（+还可以用作字符串的连接运算符）

double a = 6.3;
        double b = 2.1;
        double c = a + b;//c的值为 8.4

• -：减法运算符

double a = 6.3;
        double b = 2.1;
        double c = a - b;// c的值为 4.2

• *：乘法运算符

double a = 6.3;
        double b = 2.1;
        double c = a * b;// c的值为 13.23

• /：除法运算符，两个操作数都是整型，则除数不可以是0；有一个是浮点数或者两个都是浮点数，则除数可以是0或0.0 ， 结果为正无穷或负无穷。

double a = 6.3;
        double b = 1.2;
        double c = a / b;// c的值为 5.25

        int x = 8;
        int y = 3;
        int k = x / y;// k 的值为2

• &：求余运算符

double a = 6.3;
        double b = 2.0;
        double c = a % b;// c的值为 0.3

        int x = 8;
        int y = 3;
        int k = x % y;// k 的值为2

• ++、–：自加、自减；前缀，先执行运算，再生成值。后缀，先生成值，再执行运算。

int i = 1;
        System.out.println("i=" + i);//i=1
        System.out.println("++i = " + ++i);//++i = 2
        System.out.println("i++ =" + i++);//i++ =2
        System.out.println(" i =" + i);// i =3
        System.out.println("--i =" + --i);//--i =2
        System.out.println("i-- =" + i--);//i-- =2
        System.out.println("i = " + i);//i = 1

关系操作符

• >,<,<=,>=,==,!=;关系操作符生成的是一个boolean结果，他们计算的是操作数的值之间的关系。（== ！=比较的是对象的引用）

逻辑运算符

• &&：与，前后两个操作数必须都是true才返回true，否则返回false；
• &：不短路与，作用与&&相同，但不会短路；
• ||：或，只要两个操作数有一个为true，则返回true，否则返回false；
• |：不短路或，与||作用相同，但不会短路；
• ！：非，操作数为true返回false，操作数为false返回true；
• ^：异或，两个操作数不同时返回true，相同时返回false；

三元操作符

• 如果逻辑表达式返回true，则返回前一个表达式的值，否则返回后一个表达式的值：

String string = 5 > i ? "5大于i" : "5不大于i";
        System.out.println(string);

• 大部分时候三元运算符为 if else 的精简写法：

String str = "";
        if (5 > i) {
            str = "5大于i";
        } else {
            str = "5不大于i";
        }
        System.out.println(str);

8.流程控制

8.1分支结构

• if语句与switch语句，一般switch用于等值判断，多重if用于区间判断；switch结构必须使用break才能跳出，多重if只要满足某个条件执行完相应的代码后会自动跳出。

if条件语句

• if语句使用布尔表达式或布尔值作为分支条件来进行分支控制，if语句有三种方式：

int num=new Random().nextInt(10);
        if(num>5){
            System.out.println("num>5");
        }
        System.out.println("...");

int num=new Random().nextInt(10);
        if(num>5){
            System.out.println("num>5");
        }else{
            System.out.println("num<=5");
        }

int num = new Random().nextInt(10);
        if (num > 5) {
            System.out.println("num>5");
        } else if (num > 3) {
            System.out.println("num>3&&num<=5");
        } else if (num > 0) {
            System.out.println("num>0&&num<=3");
        } else {
            System.out.println("num==0");
        }

switch分支语句

• switch语句后面的控制表达式的数据类型只能是byte,short,char,int四个整数类型和枚举类型，Java1.7之后允许String类型。

int num2 = new Random().nextInt(3);
        switch (num2) {
        case 0:
            System.out.println("num2=0");
            break;
        case 1:
            System.out.println("num2=1");
            break;
        case 2:
            System.out.println("num2=2");
            break;
        default:
            System.out.println("...");
            break;
        }

8.2循环结构

• 循环体如果只有一条语句，可以省略花括号；

while循环

• while循环先判断再执行循环，当循环条件不满足时，循环一次都不执行。

int count=0;
        while(count<5){
            System.out.println(count);
            count++;
        }
        System.out.println("循环结束");

• 死循环情况

int count=0;
        //死循环
        while(count<5){
            System.out.println(count);
            count--;
        }
        System.out.println("循环结束");

do while 循环

• 先执行，再判断。安全性不高，当循环条件不成立时，循环至少执行一次。

int count2 = 0;
        do {
            System.out.println(count2);
            count2++;
        } while (count2 < 5);
        System.out.println("循环结束");

for循环

• 先判断，在执行。

for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
        System.out.println("循环结束");

• for循环允许同时指定多个初始化语句，循环条件也可以是一个包含逻辑运算符的表达式。

for (int a = 0, b = 0, c = 0; a < 4 && b < 4 && c < 7; a++) {
            System.out.println(a++);
            System.out.println(b++);
        }

• for循环还可以把初始化条件定义在循环体之外，把循环迭代语句放在循环体内，不过这样就非常类似while循环。

int count = 0;
        for (; count < 5;) {
            System.out.println(count);
            count++;
        }
        System.out.println("循环结束");

foreach循环

• foreach循环操作数组和集合时更加方便

int[] is = new int[5];
        for (int i = 0; i < 5; i++) {
            is[i] = new Random().nextInt(10);
        }
        // foreach循环
        for (int i : is) {
            System.out.println(i);
        }

循环嵌套

• 循环嵌套既可以是for循环嵌套while循环，也可以是while循环嵌套do while循环等等…各种类型的循环都可以作为外循环，也可以作为内循环。

// 外层循环
        for (int i = 0; i < 5; i++) {
            // 内层循环
            for (int j = 0; j < 5; j++) {
                System.out.println("i=" + i + ",,,j=" + j);
            }
        }

使用break结束循环

• break用于完全结束一个循环，跳出循环体；

/**
         * output: i=0 i=1 i=2 i=3 i=4 i=5
         * 
         */
        for (int i = 0; i < 10; i++) {
            System.out.println("i=" + i);
            if (i == 5) {
                break;
            }
        }

使用continue结束本次循环

• continue只是终止本次循环，接着开始下一次循环。

/**
         * output: i=0 i=1 i=2 i=4
         */
        for (int i = 0; i < 5; i++) {
            if (i == 3) {
                continue;
            }
            System.out.println("i=" + i);
        }

使用return结束方法

• return的功能是结束一个方法。

/**
         * output:i=0 i=1 i=2
         */
        for (int i = 0; i < 5; i++) {
            if (i == 3) {
                return;
            }
            System.out.println("i=" + i);
        }

9.Java的注释

• 单行注释：//后面的都是注释内容
• 多行注释：/* 中间的都是注释内容/
• 文档注释：/** 中间的都是注释内容/ 生成Java api 文档

10.类型转换

• 自动类型转换：小–>大

• 多个变量做算术运算时，最终表达式的值的类型会和这几个变量类型最大的一致。
• byte–>short–>int–>long–>float–>double

• 强制类型转换：大–>小

double b=2.0;
        int a=(int)b;

11.数组

• 理解数组：数组也是一种类型，数组是引用类型。
• Java数组要求所有的数组元素具有相同的数据类型，即一个数组里只能存储一种数据类型的数据。
• Java数组既可以存储基本类型的数据，也可以存储引用类型的数据。

定义数组

type [] arrayName;
        type arrayName[];

• 使用第一种具有更好的语意，具有更好的可读性。

数组的初始化

• 静态初始化

int[] is;
        // 使用静态初始化，初始化数组只指定数组元素的初始值，不指定数组长度
        is = new int[] { 1, 2, 4, 5, 7, 56 };
        Object[] obj1;
        // 使用静态初始化，初始化数组的数组元素类型是定义数组时数组元素的子类
        obj1 = new String[] { "as", "ada" };
        // 数组的定义和初始化同时完成
        int[] a = new int[] { 1, 4, 6, 7 };
        // 简化的静态初始化写法
        int[] b = { 3, 4, 5, 6, 6 };

• 动态初始化

// 动态初始化数组长度
        int[] nums = new int[10];
        // 给每个数组元素分配初始值
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i;
        }

• 注意：不要同时使用静态初始化和动态初始化，就是不要在数组初始化时，既指定数组的长度，也给每个数组元素分配初始值。
• 数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存，只有当该引用指向有效内存后，才可以通过该数组变量来访问数组元素。

操作数组的工具类

• Arrays类 ， 具体方法参考api；