Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date 类.
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
但是这种写法比较麻烦一些, 可以使用 import语句导入包.
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
import java.util.*;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
但是建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配
在这种情况下需要使用完整的类名
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
System.out.println(date.getTime());
}
}
可以使用import static导入包中静态的方法和字段。
import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
double x = 30;
double y = 40;
// 静态导入的方式写起来更方便一些.
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
double result = sqrt(pow(x, 2) + pow(y, 2));
System.out.println(result);
}
}
**注意事项:**import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要. import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using
public class Person {
//实例成员变量
public String name;
public String sex;
public int age;
//示例代码块
{
this.name="zhangsan";
this.sex="男";
this.age=18;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
public static void main(String[] args) {
Person p1=new Person();
System.out.println(p1.toString());
}
}
3.4 静态代码块
使 用 s t a tic 定 义 的 代 码 块 称 为 静 态 代 码 块 。
一 般 用 于 初 始 化 静 态 成 员 变 量 。
public class Person {
//实例成员变量
static String name;
static String sex;
static int age;
//示例代码块
static{
name="zhangsan";
sex="男";
age=18;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
public static void main(String[] args) {
Person p1=new Person();
System.out.println(p1.toString());
}
}
public class OutClass {
// 成员位置定义：未被static修饰 --->实例内部类
public class InnerClass1{
}
// 成员位置定义：被static修饰 ---> 静态内部类
static class InnerClass2{
}
public void method(){
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
class InnerClass5{
}
}
}
4.1 实例内部类
即未被static修饰的成员内部类。
++1. 外部类中的任何成员都可以在实例内部类方法中直接访问++
public class OutClass {
public int data1=1;
private int data2=2;
int data3=3;
public static int data4=4;
public void outMethodA(){
System.out.println("data1:"+data1);
}
public static void outMethodB(){
System.out.println("data4:"+data4);
}
//定义一个实例内部类
class innerClass{
//在实例内部类当中：可以访问任意访问修饰限定符的成员
//在实例内部类当中创建一个方法
public void innerMethod(){
// 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
data1=10;
data2=20;
data3=30;
data4=40;
outMethodA();
outMethodB();
System.out.println("data1:"+data1);
System.out.println("data2:"+data2);
System.out.println("data3:"+data3);
System.out.println("data4:"+data4);
}
}
public static void main(String[] args) {
//OutClass.innerClass inner=new OutClass().new innerClass();
OutClass out=new OutClass();
OutClass.innerClass inner=out.new innerClass();
inner.innerMethod();
}
}
public class OutClass {
int a = 10;
public void method(){
int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用，其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
}
}
++【注意事项】++
++1. 局部内部类只能在所定义的方法体内部使用++
++2. 不能被public、static等修饰符修饰++
++3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class++
++4. 几乎不会使用++
4.4 匿名内部类
5、对象的打印
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);
}
}
// 打印结果：day20210829.Person@1b6d3586
++我们可以简单的认为打印了一个类似与地址的东西（实际上是该类所创建对象的哈希值）++
如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。
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;
}
@Override
public String toString() {
return "[" + name + "," + gender + "," + age + "]";
}
public static void main(String[] args) {
Person person = new Person("Jim","男", 18);
System.out.println(person);
}
}
// 输出结果：[Jim,男,18]
假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给类中再加一个成 员变量，来保存同学上课时的教室呢？答案是不行的。
