对象类与数据类型

1、Java语法基础

Java基本概念

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

Java代码规范

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

Java标识符

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

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

2、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步：

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

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");
    }
}

访问实例变量和方法

直接看例子如下：

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);
    }
}

源文件的声明规则

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

一个简单的实例

首先新建一个文件：Employee.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

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

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

引用数据类型

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

Java常量

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

final double PI = 3.1415926;

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

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

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

Java的自动类型转换

转换由低级到高级如下：

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

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

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

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

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

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

Java的强制类型转换

要求：

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

实例如下：

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

Java隐含强制类型转换

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

参考链接

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