对象类与数据类型¶

1、Java语法基础¶

Java基本概念¶

对象：对象是类的一个实例，有状态和行为；
类：类是一个模板，它描述一类对象的行为和状态；
方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的；
实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

Java代码规范¶

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如MyFirstJavaClass。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
Java的注释方式同C++语言。

Java标识符¶

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
关键字不能用作标识符，标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary

2、Java枚举类型¶

枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

Java
class FreshJuice {
    enum FreshJuiceSize{ MEDIUM, LARGE, SUPERLARGE }
    FreshJuiceSize size;
}

public class FreshJuiceTest {
    public static void main(String[] args) {
        FreshJuice juice = new FreshJuice();
        juice.size = FreshJuice.FreshJuiceSize.SUPERLARGE;
    }
}

3、Java的对象和类¶

Java是一种面向对象的语言，支持：多态、继承、封装、抽象、类、对象、实例、方法、重载。

对象：对象是类的一个实例，具有状态和行为。
类：类是一个模板，描述一类对象的行为和状态。

创建对象¶

创建对象分3步：

声明：声明一个对象，包括其名称和类型；
实例化：使用关键字new创建一个对象；
初始化：使用new创建对象时，将会构造方法初始化对象。

Java
public class Puppy {
    // 下面构造器的参数只有一个 name
    public Puppy(String name) {
        System.out.println("the puppy's name is " + name);
    }

    public static void main(String[] args) {
        // 创建对象 myPuppy
        Puppy myPuppy = new Puppy("tommy");
    }
}

访问实例变量和方法¶

直接看例子如下：

Java
public class Puppy {
    int puppyAge;
    public Puppy(String name) {
        System.out.println("the puppy's name is " + name);
    }

    public void setAge(int age) {
        puppyAge = age;
    }

    public int getAge() {
        System.out.println("the puppy's age is " + puppyAge);
        return puppyAge;
    }

    public static void main(String[] args) {
        Puppy myPuppy = new Puppy("tommy"); //创建对象
        myPuppy.setAge(2); // 设定 age
        myPuppy.getAge(); // 获取 age

        // 访问成员变量
        System.out.println("Age = " + myPuppy.puppyAge);
    }
}

源文件的声明规则¶

一个源文件中可以有多个非 public 类，但只能有一个 public 类；
源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Puppy，那么源文件应该命名为 Puppy.java。
如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
java因强制要求类名（唯一的public类）和文件名统一，因此在引用其它类时无需显式声明。在编译时，编译器会根据类名去寻找同名文件。

一个简单的实例¶

首先新建一个文件：Employee.java 如下：

Java
import java.io.*;

public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // Employee 类的构造器
   public Employee(String name){
      this.name = name;
   }
   // 设置age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 设置designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* 设置salary的值*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* 打印信息 */
   public void printEmployee(){
      System.out.println("名字:"+ name );
      System.out.println("年龄:" + age );
      System.out.println("职位:" + designation );
      System.out.println("薪水:" + salary);
   }
}

Java程序从main函数开始执行，因而还需要另外一个包含main方法的java文件：EmployeeTest.java

Java
import java.io.*;

public class EmployeeTest{
   public static void main(String[] args){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("RUNOOB1");
      Employee empTwo = new Employee("RUNOOB2");

      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("高级程序员");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("菜鸟程序员");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

4、Java的基本数据类型¶

Java语言包含内置数据类型和引用数据类型两种。

内置数据类型¶

Java提供了8种基本数据类型，包括：

4种整数型数字类型（byte, short, int, long）
2种浮点型数字类型（float, double）
1种字符类型（char）
1种布尔类型（boolean）

一个例子直接展示以上数据类型的包装类，二进制位数（xxx.SIZE），最小值（xxx.MIN_VALUE），最大值（xxx.MAX_VALUE）：

Java
public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
        // byte，默认值为 0
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  
        System.out.println();  

        // short，默认值为 0
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
        System.out.println();  

        // int，默认值为 0
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  

        // long，默认值为 0L
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  

        // float，默认值为 0.0f
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  

        // double，默认值为 0.0d
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  

        // char，默认值为 'u0000'，String类型的默认值是 null
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
        System.out.println("最小值：Character.MIN_VALUE="  
                + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
        System.out.println("最大值：Character.MAX_VALUE="  
                + (int) Character.MAX_VALUE);  

        // boolean的默认值为 false
    }  
}

引用数据类型¶

Java中的引用类型变量类似于C++中的指针。引用类型指向一个对象，指向对象的变量是引用变量。且此变量一旦声明后，无法改变；
对象和数组都是引用数据类型；
所有引用类型的默认值都是null；
一个引用变量可以用来引用任何与之兼容的类型；
如Site site = new Site("dog")。

Java常量¶

在Java中，使用final关键词修饰常量：

Java
final double PI = 3.1415926;

注意：通常使用大写字母表示常量。

在Java中，byte，short，int，long 都可以使用十进制、16进制、8进制表示：

Java
int decimal = 100;
int octal = 0144;
int hexa = 0x64;

Java的自动类型转换¶

转换由低级到高级如下：

Java
byte, short, char -> int -> long -> float -> double

在数据类型转换时，需要满足以下规则：

boolean类型数据无法转换；
不能把对象类型转换成不相关类的对象；
在把容量大的类型转换为容量小的类型时必须使用强制类型转换；
转换过程中可能导致溢出或损失精度，例如：

Java
int i =128;
byte b = (byte)i;
// byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

Java
(int)23.7 == 23;
(int)-45.89f == -45;

Java的强制类型转换¶

要求：

条件是转换的数据类型必须是兼容的；
格式：(type)value，其中type是要强制类型转换后的数据类型。

实例如下：

Java
public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}

Java隐含强制类型转换¶

整数的默认类型是 int。
浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

参考链接¶

菜鸟教程：Java基础语法
菜鸟教程：Java对象和类
菜鸟教程：Java基本数据类型