Java快速入门-02-基础篇

川长思鸟来 2022-05-11 04:00 208阅读 0赞

## Java快速入门-02-基础篇 ##

*  上一篇应该已经让0基础的人对 Java 有了一些了解，接一篇更进一步

### 使用 Eclipse 快捷键 ###

*  这个老师一般都经常提，但是自己不容易记住，慢慢熟练

<table> 
 <tbody> 
  <tr> 
   <th>快捷键</th> 
   <th>快捷键作用</th> 
  </tr> 
  <tr> 
   <td>Ctrl + Shfit + O</td> 
   <td>引入及管理 import 语句</td> 
  </tr> 
  <tr> 
   <td>Ctrl + Shfit + F4/Ctrl + W</td> 
   <td>挂你比打开的窗口</td> 
  </tr> 
  <tr> 
   <td>Ctrl + Shfit + F</td> 
   <td>自动调整所选代码格式化</td> 
  </tr> 
  <tr> 
   <td>Ctrl + /</td> 
   <td>注释本行</td> 
  </tr> 
  <tr> 
   <td>Ctrl + E</td> 
   <td>打开编辑器 / 切换窗口</td> 
  </tr> 
  <tr> 
   <td>Ctrl + D</td> 
   <td>删除本行</td> 
  </tr> 
  <tr> 
   <td>Alt + Shfit + R</td> 
   <td>注释本行</td> 
  </tr> 
  <tr> 
   <td>Alt + Shfit + L</td> 
   <td>（常用）抽取本地变量</td> 
  </tr> 
  <tr> 
   <td>Alt + Shfit + M</td> 
   <td>抽取方法</td> 
  </tr> 
  <tr> 
   <td>Ctrl + Alt + 上（下）</td> 
   <td>向上或向下复制文本</td> 
  </tr> 
  <tr> 
   <td>Alt + 上（下）</td> 
   <td>向上或向下移动文本</td> 
  </tr> 
 </tbody> 
</table>

### 对象的类 ###

*  Java 作为一种面向对象语言，支持以下基本概念：
 *  多态、继承、封装、抽象、类、对象、实例、方法、重载
 *  **重点研究对象的类的概念**
 *  对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等
 *  类：类是一个模板，它描述一类对象的行为和状态

### Java中的对象 ###

*  现在让我们深入了解什么是对象。看看周围真实的世界，会发现身边有很多对象，车，狗，人等等。所有这些对象都有自己的状态和行为
 *  拿一条狗来举例，它的状态有：名字、品种、颜色，行为有：叫、摇尾巴和跑
 *  对比现实对象和软件对象，它们之间十分相似
 *  软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。
 *  在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成

### Java中的类 ###

*  类可以看成是创建Java对象的模板。
 *  通过下面一个简单的类来理解下Java中类的定义：

public class Dog{
      String breed;
      int age;
      String color;
      void barking(){
      }
     
      void hungry(){
      }
     
      void sleeping(){
      }
    }

*  一个类可以包含以下类型变量：
 *  局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
 *  成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
 *  类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。  
    一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法

### 构造方法 ###

*  每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法
 *  在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法
 *  下面是一个构造方法示例：  
    ![70][]
 *  这里需要注意的是构造方法是对于指这个类的方法，所以我们要分清是哪个类的方法，public 方法的方法名称要和类名一致，private 方法可以自定义
 *  private 方法创建的快捷方式：直接输入方法名，按下 Alt + / 键，回车

### 创建对象 ###

*  对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：
 *  声明：声明一个对象，包括对象名称和对象类型。
 *  实例化：使用关键字new来创建一个对象。
 *  初始化：使用new创建对象时，会调用构造方法初始化对象。
 *  下面是一个创建对象的例子：  
    ![70 1][]
 *  注意：
 *  1.里面定义的类在 class 前面加上了 static，因为我们的 main 方法是 static，
 *  2.注意大括号层级，结构
 *  编译并运行上面的程序，会打印出下面的结果：

小狗的名字是 : tommy
    learn.learn01$Puppy@33909752

### 访问实例变量和方法 ###

*  通过已创建的对象来访问成员变量和成员方法，如下所示：
 *  看不懂没关系，了解一下往下看

/* 实例化对象 */
    ObjectReference = new Constructor();
    /* 访问类中的变量 */
    ObjectReference.variableName;
    /* 访问类中的方法 */
    ObjectReference.methodName();

### 为了更熟练掌握对象 类 构造方法看下面实例 ###

*  请看注释

public class Puppy{
       int puppyAge;
       public Puppy(String name){
          // 这个构造器仅有一个参数：name
          System.out.println("小狗的名字是 : " + name ); 
       }
       // void 表示没有返回值
       public void setAge( int age ){
           puppyAge = age;
       }
     
       public int getAge( ){
           System.out.println("小狗的年龄为 : " + puppyAge ); 
           return puppyAge;
       }
     
       public static void main(String []args){
          /* 创建对象 */
          Puppy myPuppy = new Puppy( "tommy" );
          /* 通过方法来设定age */
          myPuppy.setAge( 2 );
          /* 调用另一个方法获取age */
          myPuppy.getAge( );
          /*你也可以像下面这样访问成员变量 */
          System.out.println("变量值 : " + myPuppy.puppyAge ); 
       }
    }

*  编译并运行上面的程序，产生如下结果：

小狗的名字是 : tommy
    小狗的年龄为 : 2
    变量值 : 2

### 源文件声明规则 ###

*  这里有你们的疑问
 *  当在一个源文件中定义多个类，并且还有 import 语句和 package 语句时，要特别注意这些规则
 *  一个源文件中只能有一个 public 类
 *  一个源文件可以有多个非 public 类
 *  源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为 Employee.java
 *  如果一个类定义在某个包中，那么 package 语句应该在源文件的首行
 *  如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面
 *  import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明

类有若干种访问级别，并且类也分不同的类型：抽象类和final类等。这些将在访问控制章节介绍  
除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类

--------------------

### Java 包 ###

*  包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类

### Import语句 ###

*  在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类
 *  例如，下面的命令行将会命令编译器载入java\_installation/java/io路径下的所有类

import java.io.*;

### 一个简单的例子 ###

*  在该例子中，我们创建两个类：Employee 和 EmployeeTest
 *  首先在 Eclipse 中新建 java class文件： Employee.java
 *  也可以打开文本编辑器，把下面的代码粘贴进去。注意将文件保存为 Employee.java
 *  Employee 类有四个成员变量：name、age、designation和salary。该类显式声明了一个构造方法，该方法只有一个参数

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

*  程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象
 *  下面给出EmployeeTest类，该类实例化2个 Employee 类的实例，并调用方法设置变量的值
 *  将下面的代码保存在 EmployeeTest.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();
       }
    }

*  编译这两个文件并且运行 EmployeeTest 类，可以看到如下结果：
 *  也可以在 Eclipse 中运行 EmployeeTest.java 文件

$ javac EmployeeTest.java
    $ java EmployeeTest 
    名字:RUNOOB1
    年龄:26
    职位:高级程序员
    薪水:1000.0
    名字:RUNOOB2
    年龄:21
    职位:菜鸟程序员
    薪水:500.0

### Java 基本数据类型 ###

*  变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间
 *  内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据  
    ![在这里插入图片描述][70 2]
 *  因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符
 *  Java 的两大数据类型:
    
     *  内置数据类型
     *  引用数据类型

### 内置数据类型 ###

*  Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型

### byte： ###

*  byte 数据类型是8位、有符号的，以二进制补码表示的整数；
 *  最小值是 -128（-2^7）
 *  最大值是 127（2^7-1）
 *  默认值是 0
 *  byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一
 *  例子：byte a = 100，byte b = -50

### short： ###

*  short 数据类型是 16 位、有符号的以二进制补码表示的整数
 *  最小值是 -32768（-2^15）
 *  最大值是 32767（2^15 - 1）
 *  Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一
 *  默认值是 0
 *  例子：short s = 1000，short r = -20000

### int： ###

*  int 数据类型是32位、有符号的以二进制补码表示的整数
 *  最小值是 -2,147,483,648（-2^31）
 *  最大值是 2,147,483,647（2^31 - 1）
 *  一般地整型变量默认为 int 类型
 *  默认值是 0
 *  例子：int a = 100000, int b = -200000

### long： ###

*  long 数据类型是 64 位、有符号的以二进制补码表示的整数
 *  最小值是 -9,223,372,036,854,775,808（-2^63）
 *  最大值是 9,223,372,036,854,775,807（2^63 -1）
 *  这种类型主要使用在需要比较大整数的系统上
 *  默认值是 0L
 *  例子： long a = 100000L，Long b = -200000L
 *  "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写

### float： ###

*  float 数据类型是单精度、32位、符合IEEE 754标准的浮点数
 *  float 在储存大型浮点数组的时候可节省内存空间
 *  默认值是 0.0f
 *  浮点数不能用来表示精确的值，如货币
 *  例子：float f1 = 234.5f

### double： ###

*  double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数
 *  浮点数的默认类型为double类型
 *  double类型同样不能表示精确的值，如货币
 *  默认值是 0.0d
 *  例子：double d1 = 123.4

### boolean： ###

*  boolean数据类型表示一位的信息
 *  只有两个取值：true 和 false
 *  这种类型只作为一种标志来记录 true/false 情况
 *  默认值是 false
 *  例子：boolean one = true

### char： ###

*  char类型是一个单一的 16 位 Unicode 字符
 *  最小值是 \\u0000（即为0）
 *  最大值是 \\uffff（即为65,535）
 *  char 数据类型可以储存任何字符
 *  例子：char letter = ‘A’;

### 实例 ###

对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：

public class PrimitiveTypeTest {  
        public static void main(String[] args) {  
            // byte  
            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  
            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  
            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  
            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  
            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  
            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  
            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);  
        }  
    }

*  编译以上代码输出结果如下所示：

基本类型：byte 二进制位数：8
    包装类：java.lang.Byte
    最小值：Byte.MIN_VALUE=-128
    最大值：Byte.MAX_VALUE=127
    
    基本类型：short 二进制位数：16
    包装类：java.lang.Short
    最小值：Short.MIN_VALUE=-32768
    最大值：Short.MAX_VALUE=32767
    
    基本类型：int 二进制位数：32
    包装类：java.lang.Integer
    最小值：Integer.MIN_VALUE=-2147483648
    最大值：Integer.MAX_VALUE=2147483647
    
    基本类型：long 二进制位数：64
    包装类：java.lang.Long
    最小值：Long.MIN_VALUE=-9223372036854775808
    最大值：Long.MAX_VALUE=9223372036854775807
    
    基本类型：float 二进制位数：32
    包装类：java.lang.Float
    最小值：Float.MIN_VALUE=1.4E-45
    最大值：Float.MAX_VALUE=3.4028235E38
    
    基本类型：double 二进制位数：64
    包装类：java.lang.Double
    最小值：Double.MIN_VALUE=4.9E-324
    最大值：Double.MAX_VALUE=1.7976931348623157E308
    
    基本类型：char 二进制位数：16
    包装类：java.lang.Character
    最小值：Character.MIN_VALUE=0
    最大值：Character.MAX_VALUE=65535

Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。

实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作

### 引用类型 ###

*  在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了
 *  对象、数组都是引用数据类型
 *  所有引用类型的默认值都是null
 *  一个引用变量可以用来引用任何与之兼容的类型
 *  例子：Site site = new Site(“Runoob”)

### Java 常量 ###

*  常量在程序运行时是不能被修改的。
 *  在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

*  虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。
 *  字面量可以赋给任何内置类型的变量。例如：

byte a = 68;
    char a = 'A'

*  byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
 *  当使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：

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

*  和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World"
    "two\nlines"
    "\"This is in quotes\""

*  字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';
    String a = "\u0001";

*  Java语言支持一些特殊的转义字符序列

<table> 
 <tbody> 
  <tr> 
   <th> 符号</th> 
   <th> 字符含义</th> 
  </tr> 
  <tr> 
   <td> \n</td> 
   <td> 换行 (0x0a)</td> 
  </tr> 
  <tr> 
   <td> \r</td> 
   <td> 回车 (0x0d)</td> 
  </tr> 
  <tr> 
   <td> \f</td> 
   <td> 换页符(0x0c)</td> 
  </tr> 
  <tr> 
   <td> \b</td> 
   <td> 退格 (0x08)</td> 
  </tr> 
  <tr> 
   <td> \0</td> 
   <td> 空字符 (0x20)</td> 
  </tr> 
  <tr> 
   <td> \s</td> 
   <td> 字符串</td> 
  </tr> 
  <tr> 
   <td> \t</td> 
   <td> 制表符</td> 
  </tr> 
  <tr> 
   <td> \"</td> 
   <td> 双引号</td> 
  </tr> 
  <tr> 
   <td> \'</td> 
   <td> 单引号</td> 
  </tr> 
  <tr> 
   <td> \\</td> 
   <td> 反斜杠</td> 
  </tr> 
  <tr> 
   <td> \ddd</td> 
   <td> 八进制字符 (ddd)</td> 
  </tr> 
  <tr> 
   <td> \uxxxx</td> 
   <td> 16进制Unicode字符 (xxxx)</td> 
  </tr> 
 </tbody> 
</table>

### 自动类型转换 ###

*  整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算
 *  转换从低级到高级

低  ------------------------------------>  高
    byte,short,char—> int —> long—> float —> double

**数据类型转换必须满足如下规则：**

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

int i =128;   
    byte b = (byte)i;

*  因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出
 *  1.  浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

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

### 自动类型转换 ###

*  必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型
 *  实例：

public class ZiDongLeiZhuan{
            public static void main(String[] args){
                char c1='a';//定义一个char类型
                int i1 = c1;//char自动类型转换为int
                System.out.println("char自动类型转换为int后的值等于"+i1);
                char c2 = 'A';//定义一个char类型
                int i2 = c2+1;//char 类型和 int 类型计算
                System.out.println("char类型和int计算后的值等于"+i2);
            }
    }

*  运行结果为:

char自动类型转换为int后的值等于97
    char类型和int计算后的值等于66

解析：c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97， A 对应值为 65，所以 i2=65+1=66

### 强制类型转换 ###

*  1.  条件是转换的数据类型必须是兼容的。
 *  1.  格式：(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);
        }
    }

*  运行结果：

int 强制类型转换为 byte 后的值等于 123

### 隐含强制类型转换 ###

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

### 更多文章链接：[Java 快速入门][Java] ###

--------------------

本笔记不允许转载

[70]: /images/20220511/35e39a4bc2c1403c82d33b378188fe28.png
[70 1]: /images/20220511/cc14918ae8b84a508beb5805fc2225db.png
[70 2]: /images/20220511/613e98bbccaa44d68d30d10bb1385dc0.png
[Java]: https://blog.csdn.net/qq_40147863/article/category/8055547