电玩棋牌游戏送30元 当前位置:首页>电玩棋牌游戏送30元>正文

电玩棋牌游戏送30元

发布时间:2018-11-15

原标题:原来你是这样的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 class PrimitiveDemo {
     public static void main(String[] args) {
         int num = 10;
         change(num);
         System.out.println("main() a=" + num);//10
     }

    private static void change(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=20
main() a=10

 

2.对象参数传递引用的拷贝
这个地方,在看《JAVA核心技术I》的时候,作者说的是“JAVA程序设计语言总是按值传递”,这个描述感觉不是太赞同。看了后面的描述:“方法得到的是对象引用的拷贝,对象引用及其他拷贝都同时引用同一对象”。大体和我理解的意思是一致的,也就不纠结说法了。
为方便测试,首先我们定义一个类Book:

class Book {
     private int price;

    public void setPrice(int price) {
         this.price = price;
     }

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

    @Override
     public String toString() {
         return super.toString() + "[price=" + price + "]";
     }
}

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

public class ObjectDemo {
     public static void main(String[] args) {
         Book book = new Book(10);
         System.out.println("①" + book.toString());
         change(book);
         System.out.println("③" + book.toString());
     }

    private static void change(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 class ObjectDemo2 {
     
public static void main(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 void swap(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的地址。

image

三、构造函数


说起构造函数大家一点都不陌生,但有几点要注意的地方:
1.仅当没有提供任何构造器的时候,系统才会默认提供一个无参构造器。
2.构造函数可以调用另一个构造函数,但是必须遵守以下几个规则:
* 构造函数调用必须位于第一行;
* 构造函数只能被调用一次;
* 不能在构造函数以外的任何位置调用构造函数。

public class Person {
     private String name;
     private Integer age;

    public Person(String name) {
         this.name = name;
     }

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

    @Override
     public String toString() {
         return "Person{" +
                 "name="" + name + """ +
                 ", age=" + age +
                 "}";
     }

    public static void main(String[] args) {
         Person p = new Person("a", 11);
         System.out.println(p);
     }
}

 

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

public class Order {
     OrderDetail d1 = new OrderDetail(100);
     OrderDetail d2 = new OrderDetail(200);

    public Order() {
         OrderDetail d3 = new OrderDetail(300);
     }

    OrderDetail d4 = new OrderDetail(400);

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

class OrderDetail {
     public OrderDetail(Integer price) {
         System.out.println("OrderDetail price=" + price);
     }
}

执行结果:

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

编辑:安宗陵伯

发布时间:2018-11-15 00:00:00

当前文章:http://www.radiokey.biz/ask/18-11-1027022.html

花猪四川棋牌 欢乐电玩城手机版 棋牌游戏平台送现金 天天电玩城全是机器人 天天棋牌唯一官网 微乐辽宁棋牌电脑版 新2网站手机版 熊猫麻将app器app

28219 94147 81647 45025 28796 5769548490 35691 49945

责任编辑:徒安

随机推荐