java创建2参构造器_原来你是这样的JAVA[02]-包、传参、构造器

一、包(package)

在java程序中，一个java源文件称为编译单元，以.java后缀命名。编译单元内可以有一个public类，类名必须与文件名相同。注意：每个编译单元只能有一个public类。

在C#中，我们用命名空间namespace来组织类库，用using关键字导入某个命名空间。Java中有同样的概念成为包，关键字是package，使用import关键字导入包。

1.package:

类库就是一组文件，每个文件都有一个public类，以及任意数量的非public类。package语句用来指定当前文件所属的类库，它必须放在文件开始，除注释外的第一行代码。例如：package com.cathy.dto;

2.import:

如果想使用某个包中的类，需要使用import导入对响应包的引用。如果导入包中的多个类，可以使用import.cathy.dto.*;

3.访问修饰符：

public:修饰的成员任何人都可以使用。

private:除了包含该成员的类，其他类都无法访问该成员。

protected：继承访问权限。

有一点需要注意：在C#中，类中的成员如果不添加访问修饰符默认是private；但是在Java中如果不提供任何访问修饰词，默认是包访问权限，处于同一个编译单元中的所有类彼此之间都是自动可访问的。

二、方法传参

1.基本类型作为参数传递

八种基本数据类型(byte,short,int,long,double,float,char,boolean)作为参数传递时，传递的是值的拷贝。所以，方法中任何操作都不会修改原值。

public classPrimitiveDemo {public static voidmain(String[] args) {int num = 10;

change(num);

System.out.println("main() a=" + num);//10

}private static voidchange(Integer a) {

System.out.println("1 change() a=" +a);

a= 20;

System.out.println("2 change() a=" +a);

}

}

运行结果：

1 change() a=10

2 change() a=20main() a=10

2.对象参数传递引用的拷贝

这个地方，在看《JAVA核心技术I》的时候，作者说的是“JAVA程序设计语言总是按值传递”，这个描述感觉不是太赞同。看了后面的描述：“方法得到的是对象引用的拷贝，对象引用及其他拷贝都同时引用同一对象”。大体和我理解的意思是一致的，也就不纠结说法了。

为方便测试，首先我们定义一个类Book:

classBook {private intprice;public void setPrice(intprice) {this.price =price;

}public Book(intprice) {this.price =price;

}

@OverridepublicString toString() {return super.toString() + "[price=" + price + "]";

}

}

当为对象类型赋值时，实际上是将两个对象指向了同一个引用，自然也就很容易修改引用对象的属性了。

public classObjectDemo {public static voidmain(String[] args) {

Book book= new Book(10);

System.out.println("①" +book.toString());

change(book);

System.out.println("③" +book.toString());

}private static voidchange(Book book) {

book.setPrice(20);

System.out.println("②change()" +book);

}

}

运行结果：

①Book@7440e464[price=10]

②change()Book@7440e464[price=20]

③Book@7440e464[price=20]

从运行结果可以看出：change()方法中的book参数确实和原对象指向了同一地址，也就是说在Java中对象作为参数传递时，实际上是把对象在内存中的地址拷贝传给了参数。这样一来，对参数对象book的修改也就修改了原对象。

到这里我就想，两个对象指向的内存地址是一样的，那会不会对象作为参数时，直接传递的就是该对象的引用呢？如果这样的话，我们修改一下参数book的指向，看看会不会影响原有对象的引用。

public classObjectDemo2 {public static voidmain(String[] args) {

Book b1=new Book(10);

Book b2=new Book(20);

System.out.println("before swap" + b1.toString()+b2.toString());

swap(b1,b2);

System.out.println("after swap" + b1.toString()+b2.toString());

}private static voidswap(Book pb1, Book pb2) {

Book temp=pb1;

pb1=pb2;

pb2=temp;

System.out.println("swap() pb1 " +pb1);

System.out.println("swap() pb2 " +pb2);

pb1.setPrice(100);

pb2.setPrice(200);

}

}

运行结果：

before swapBook@7440e464[price=10] Book@49476842[price=20]

swap() pb1 Book@49476842[price=20]

swap() pb2 Book@7440e464[price=10]

after swapBook@7440e464[price=200] Book@49476842[price=100]

可以看到b1和b2引用的对象并没有变化，交换的只是拷贝的引用pb1和pb2的地址。

三、构造函数

说起构造函数大家一点都不陌生，但有几点要注意的地方：

1.仅当没有提供任何构造器的时候，系统才会默认提供一个无参构造器。

2.构造函数可以调用另一个构造函数，但是必须遵守以下几个规则：

* 构造函数调用必须位于第一行；

* 构造函数只能被调用一次；

* 不能在构造函数以外的任何位置调用构造函数。

public classPerson {privateString name;privateInteger age;publicPerson(String name) {this.name =name;

}publicPerson(String name, Integer age) {this(name);this.age =age;

}

@OverridepublicString toString() {return "Person{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}public static voidmain(String[] args) {

Person p= new Person("a", 11);

System.out.println(p);

}

}

3.初始化顺序：先初始化变量，后调用构造函数。

在同一个类中，变量的初始化是和定义的先后顺序一致的。不过，即使变量定义在构造函数的后面，仍然会先初始化所有变量，然后才执行构造函数。

public classOrder {

OrderDetail d1= new OrderDetail(100);

OrderDetail d2= new OrderDetail(200);publicOrder() {

OrderDetail d3= new OrderDetail(300);

}

OrderDetail d4= new OrderDetail(400);public static voidmain(String[] args) {newOrder();

}

}classOrderDetail {publicOrderDetail(Integer price) {

System.out.println("OrderDetail price=" +price);

}

}

执行结果：

OrderDetail price=100OrderDetail price=200OrderDetail price=400OrderDetail price=300