import java.util.Date;
import java.sql.Date; //编译器会报错

import java.util.*;

import java.sql.*;

public class Test {

public static void main(String[] args) {

Date date = new Date();// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错

java.util.Date date = new java.util.Date();//这样才正确。

System.out.println(date.getTime());

}

}

// 编译出错

Error:(5, 9) java: 对Date的引用不明确

java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

3.3自定义包

3.包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.

4.如果一个类没有 package 语句, 则该类被放到一个默认包中(即src).

此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了.

3.4包的访问权限控制举例

package com.bit.demo1;

public class Computer {

private String cpu; // cpu

private String memory; // 内存

public String screen; // 屏幕

String brand; // 品牌

public Computer(String brand, String cpu, String memory, String screen) {

this.brand = brand;

this.cpu = cpu;

this.memory = memory;

this.screen = screen;

}

public void Boot(){

System.out.println("开机~~~");

}

public void PowerOff(){

System.out.println("关机~~~");

}

public void SurfInternet(){

System.out.println("上网~~~");

}

六、static关键字

1.为什么要有static

1.对变量：如果想要使所有对象有相同的初始值，就要使用static.
例如三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成
员信息，这些信息就是对不同学生来进行描述的，但是如果他们班级一样，此时可以用static'
2.对方法：又例如想改变静态变量的值或给静态变量赋值可以用静态方法
3.对调用方式：你可以直接通过类名来调用静态成员方法与变量而不需要创建类的实例，变方便了。

2.static修饰成员变量

public class Student{

public String name;

public String gender;

public int age;

public double score;

public static String classRoom = "Bit306";

public static void main(String[] args) {

// 静态成员变量可以直接通过类名访问

System.out.println(Student.classRoom);

// 也可以通过对象访问：但是classRoom是三个对象共享的，这种访问比较麻烦

Student s1 = new Student("Li leilei", "男", 18, 3.8);

System.out.println(s1.classRoom);

}

}

3.static修饰成员方法

共享访问：由于所有对象共享同一个静态成员方法的副本，因此任何一个对象对静态成员方法的修改都会影响到其他所有对象。这也是为什么静态成员方法通常用于执行不依赖于单个对象状态的操作。

我们在封装那里介绍了类外访问私密变量的方法，那在类外如何访问私密静态变量呢

七、代码块

1.代码块概念以及分类

1.1普通代码块

普通代码块：定义在方法中的代码块

public class Main{

public static void main(String[] args) {

{ //直接使用{}定义，普通方法块

int x = 10 ;

System.out.println("x1 = " +x);

}

int x = 100 ;

System.out.println("x2 = " +x);

}

}

// 执行结果

x1 = 10

x2 = 100

1.3 静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student{

private String name;

private String gender;

private int age;

private double score;

private static String classRoom;

//实例代码块

{

this.name = "bit";

this.age = 12;

this.gender = "man";

System.out.println("I am instance init()!");

}

// 静态代码块

static {

classRoom = "bit306";

System.out.println("I am static init()!");

}

public Student(){

System.out.println("I am Student init()!");

}

public static void main(String[] args) {

Student s1 = new Student();

Student s2 = new Student();

}

}

/*运行结果

I am static init()!
I am instance init()!
I am Student init()!
I am instance init()!         //发现这里静态内容没打印
I am Student init()!

*/

八、对象的打印

如果直接给对象名打印，结果是一个引用（地址）

public class Person {

String name;

String gender;

int age;

public Person(String name, String gender, int age) {

this.name = name;

this.gender = gender;

this.age = age;

}

public static void main(String[] args) {

Person person = new Person("Jim", "男", 18);

System.out.println(person);

}

}

//输出结果 Person@4554617c

上面也介绍了打印对象的方法，我们回忆一下一开始的狗类

class PetDog {

public String name;//名字

public String color;//颜色

// 狗的属性

public void barks() {

System.out.println(name + ": 旺旺旺~~~");

}

// 狗的行为

public void wag() {

System.out.println(name + ": 摇尾巴~~~"); //在类里面直接写name即可打印值

}                                                                  //在类外面写对象名.name即可打印值

}

public class Test1{

public static void main(String[] args) {

PetDog dogh = new PetDog(); //通过new实例化dogh这个对象

dogh.name = "阿黄";

dogh.barks();

dogh.wag();

PetDog dogs = new PetDog();//实例化dogs这个对象

dogs.name = "赛虎";

dogs.barks();

dogs.wag();

}

}

输出结果：

阿黄: 旺旺旺~~~

阿黄: 摇尾巴~~~

赛虎: 旺旺旺~~~

赛虎: 摇尾巴~~~

以上方法太过复杂，下面介绍一个简单的方法。