java：类和对象2.0

一.对1.0的构造函数的补充

1.1看下面的代码

public class Date{
       public int day;
       public int year;
       public int month;

       // 无参构造方法
public Date(){
       this.year = 1900;
       this.month = 1;
       this.day = 1;
     }

     // 带有三个参数的构造方法
public Date(int year, int month, int day) {
      this.year = year;
      this.month = month;
      this.day = day;
     }
public void printDate(){
      System.out.println(year + "-" + month + "-" + day);
     }
public static void main(String[] args) {
      Date d = new Date();
      d.printDate();
     }
}

上面的2个构造方法，名字相同，参数列表不同，构成了方法重载

1.2编译器会默认一个构造方法

如果用户没有显示定义，那么编译器会默认一个不带有任何参数的构造方法

public class Date {
      public int year;
      public int month;
      public int day;
public void printDate(){
      System.out.println(year + "-" + month + "-" + day);
   }
public static void main(String[] args) {
     Date d = new Date();
     d.printDate();
   }
}

注意：一旦用户自己定义，编译器就不会再自己生成了。如下：

public class Date {
       public int year;
       public int month;
       public int day;
public Date(int year, int month, int day) {
       this.year = year;
       this.month = month;
       this.day = day;
       }
public void printDate(){
       System.out.println(year + "-" + month + "-" + day);
      }
public static void main(String[] args) {
// 如果编译器会生成，则生成的构造方法一定是无参的
// 则此处创建对象是可以通过编译的
// 但实际情况是：编译期报错
      Date d = new Date();
      d.printDate();
     }
}
/*
Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
需要: int,int,int
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
*/

1.3构造方法中，可以通过其他this调用其他构造方法来简化代码。

public class Date {
    public int year;
    public int month;
    public int day;
// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
// 但是this(1900,1,1);必须是构造方法中第一条语句
public Date(){
    //System.out.println(year); 注释取消掉，编译会失败
      this(1900, 1, 1);
    //this.year = 1900;
    //this.month = 1;
    //this.day = 1;
}
    // 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
   }
}

注意：1.this(....)必须是构造方法中的第一条语句。

           2.不能形成环，如下所示：

public class Date {
       public int year;
       public int month;
       public int day;
// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
// 但是this(1900,1,1);必须是构造方法中第一条语句
public Date(){
     //System.out.println(year); 注释取消掉，编译会失败
       this(1900, 1, 1);
     //this.year = 1900;
     //this.month = 1;
     //this.day = 1;
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
       this.year = year;
       this.month = month;
       this.day = day;
   }
}

   3.绝大多数用public修饰，特殊情况下用private修饰

二.封装

2.1封装的概念

面向对象程序三大特性 ： 封装、继承、多态 。而类和对象阶段，主要研究的就是封装特性。何为封

装呢？简单来说，就是 套壳屏蔽细节 。

比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，

USB 插孔等，让用 户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是

CPU 、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的， CPU 内部是如何

设计的等，用户 只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此 计算

机厂商在出厂时，在外部套上壳 子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及

键盘插孔等，让用户可以与计算机进行交互即可。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和

对象进行交互。

2.2访问限定符

java中主要通过类和访问权限结合来实现封装：类可以将数据和封装数据的方法结合在一起，更符

合人类对事物的认知，而访问权限用来控制方法或者字段能否在类外进行使用。java中提供了四种

访问限定修饰符：

注：此处的default为空白，就是啥也不写的意思。

NO	范围	private	default	protected	public
1	同一包中的同一类	ok	ok	ok	ok
2	同一包中的不同类		ok	ok	ok
3	不同包中的子类			ok	ok
4	不同包中的非子类				ok

       对访问限定修饰符举个例子：

   

       public就像你长得是什么样，人人都可以看得到。

      default就像对于家里的人(同一个包中)了解你，但是外人不了解。

      

      private就像你自己的内心(同一个类中)，在想什么只有你自己知道。

     

      protected 主要是用在继承中，继承部分详细介绍

     

      default 权限指：什么都不写时的默认权限

     

      访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

      

     

public class Computer {
       private String cpu; // cpu
       private String memory; // 内存
       public String screen; // 屏幕
              String brand; // 品牌---->default属性

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("上网~~~");
     }
  }
public class TestComputer {
       public static void main(String[] args) {
       Computer p = new Computer("HW", "i7", "8G", "13*14");
             System.out.println(p.brand); // default属性：只能被本包中类访问
             System.out.println(p.screen); // public属性： 可以任何其他类访问
      // System.out.println(p.cpu);
     // private属性：只能在Computer类中访问，不能被其他类访问
   }
}

注意：一般成员变量设置为private，成员方法设置为public。

三.包

3.1包的概念

在面对对象的体系中，提出了一个软件包的概念。即：为了更好管理类，我们把多个类收集为一组，称为软件包。有点类似于目录，比如：为了更好地管理电脑里的音乐，一种好的方式就是把具有相同属性的歌曲放到同一个文件夹中，也可以对同一个文件夹中的歌曲进行更加详细的分类。

在java中也引入了包，包是对类、接口等封装机制的体现，是一种对类或接口的一种很好的组织方式。比如：一个包中的不同类不想被其他包中的类引用。包还有一个重要作用：同一个工程中允许存在名字相同的类，只要放在不同包中即可。

3.2导入包中的类

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 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

3.3自定义包

基本规则：1.在文件的最上方加上一个package语句指定该代码在哪个包中

                  2.包名需要尽量指定唯一的名字，通常会是公司的域名的颠倒形式(如:com.baidu.www)

                  3.包名要和代码路径匹配，例如创建：com.baidu.www的包，那么其对应的路径为 

                           

                    com/baidu/www来存储代码。

                  4.如果一个类中没有package语句，那么会放在默认包中。

操作步骤：

1.在IDEAL中新建一个包。

2.输入包名

3.在包中创建类

4.此时我们已经可以看到ideal已经在磁盘目录底下自动创建出来了

5.此时我们发现在新建类最上面，出现了一条package语句

3.4包访问控制权限举例

Computer 类位于 com.bit.demo1 包中， TestComputer 位置 com.bit.demo2 包中：

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("上网~~~");
     }
}

package com.bite.demo2;
import com.bite.demo1.Computer;
public class TestComputer {
       public static void main(String[] args) {
       Computer p = new Computer("HW", "i7", "8G", "13*14");
       System.out.println(p.screen);
// System.out.println(p.cpu); // 报错：cup是私有的，不允许被其他类访问
// System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问
       }
}
// 注意：如果去掉Computer类之前的public修饰符，代码也会编译失败

3.5常见的包

1. java.lang: 系统常用基础类 (String 、 Object), 此包从JDK1.1 后自动导入。

2. java.lang.reflect:java 反射编程包 ;

3. java.net: 进行网络编程开发包。

4. java.sql: 进行数据库开发的支持包。

5. java.util: 是 java 提供的工具程序包。 ( 集合类等 ) 非常重要

6. java.io:I/O 编程开发包。