Java复习笔记（一）
Java38 分钟 读完 (大约 5763 个字)

Java复习笔记（一）

Day01: 2020.09.04

今天开始复习java，一天复习一点。

参考

  1. 菜鸟教程：Java
  2. C语言中文网：Java

概述

背景

Java是Sun Microsystems在1995年发布的高级程序设计语言。

Sun Microsystems是IT及互联网技术服务公司（已被甲骨文收购）Sun Microsystems 创建于1982年。主要产品是工作站及服务器。

Java可以运行在ARM和x86多个平台上，比如windows、macos、linux、unix等等。

Java有什么：

  1. Java语言
  2. JVM
  3. Java API
  4. Javac等工具

jdk：1，2，3，4
jre（Java运行时环境）：2，3

从底层到顶层：JVM -> JRE -> JDK

HelloWorld

老规矩，现在写第一个java程序：HelloWorld.java

下面创建java文件，文件名要和类名相同。

创建HelloWorld.java文件：

1
touch HelloWorld.java

HelloWorld.java：

1
2
3
4
5
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

上面代码中的 String args[] 和 String[] args 都可以，但是还是推荐使用 String[] args 以避免歧义。

编译并运行

1
2
3
4
5
6
7
8
# 使用编译器javac将java文件编译为class字节码文件
javac HelloWorld.java

# 运行，无需加.class扩展名
java HelloWorld

# output
Hello World

简介

java体系

java有三个体系：Java EE（企业版）, Java SE（标准版）, Java ME（微型版）。
我使用了Java SE的jdk。

java特性

  • 简单
  • 面向对象
  • 分布式
  • 健壮性
  • 安全
  • 体系结构中立
  • 可移植
  • 解释型
  • 高性能
  • 多线程
  • 动态

java历史

1995年5月23日，Java语言诞生

java开发工具

硬件要求：内存1G以上。
系统要求：linux、macos、windows。
JDK：7、8…
编辑器：notepad、sublime text（收费）、vscode（开源且免费）等等。
IDE：eclipse（开源且免费）、idea（收费）等等。

编辑器/IDE这里我主要使用vscode和idea。

开发环境配置

开发java需要在机器上安装oracle jdk（java开发工具包）或者OpenJDK。

我这里使用Java SE 8。

查看是否安装成功：

jdk installation

安装成功！

基础语法

一个Java程序可以认为是一系列对象的集合，而这些对象通过彼此的方法来协同。

几个基本概念

下面十几个重要的概念：

  • 对象：对象是类的一个实例，有状态和行为。
  • 类：是一个模板，描述一类对象的状态和行为。
  • 方法：方法就是行为，逻辑运算、数据修改等所有动作都是在方法中修改的。
  • 实例变量：每个对象都有独特的实例变量，对象的状态由实例变量的值决定。

第一个java程序

实例：

1
2
3
4
5
6
7
8
public class HelloWorld {
    /* 第一个Java程序
     * 它将打印字符串 Hello World
     */
    public static void main(String[] args) {
        System.out.println("Hello World"); // 打印 Hello World
    }
}

保存、编译和运行：

  1. 创建文件：HelloWorld.java
  2. 编写代码
  3. 编译：javac HelloWorld.java
  4. 运行：java HelloWorld

基本语法

几条tips：

  1. java大小写敏感。
  2. 类名首字母大写，并且如果类名是由多个单词组成，那么每个单词首字母都要大写。
  3. 方法名以小写开头，采用驼峰式命名。
  4. java文件名和类名要相同。
  5. 主方法入口：public static void main(String[] args){}，在最后的{}中编写代码。
  6. String[] args表示传入一个String类型的数组args，可以在内部通过arg[i]获取参数，传参可以通过命令java file_name param1 param2 ...。

标识符

类名、变量名、方法名都叫做标识符。

标识符规则：

  1. 只能以A-Z,a-z,$,_开始。
  2. 第一个字符之后可以用A-Z,a-z,$,_以及数字。
  3. 关键字不能作为标识符。
  4. 标识符大小写敏感。

标识符命名习惯

  1. 标识符包含语义信息。
  2. 包名、项目名全小写。
  3. 类名每个单词首字母大写。
  4. 变量名和方法名，驼峰式。
  5. 常量名全大写，采用下划线_连接。

修饰符

java中的修饰符用来修饰类中的属性和方法。

修饰符种类：

  • 访问控制修饰符：default, public, protected, private
  • 非访问控制修饰符：final, abstract, static, synchronized

变量

java变量类型：

  • 局部变量
  • 类变量（静态变量）
  • 成员变量（非静态变量）

数组

数组是存储在堆上的对象，可以保存多个同类型的变量。

枚举

所谓枚举就是：限制了变量只能是预先设定好的值。

实例：

1
2
3
4
5
6
7
8
9
10
11
class FreshJuice {
    enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
    FreshJuiceSize size;
}

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

关键字

java关键字有这些：

java关键字

  • 访问控制

  • 类、方法、变量修饰符

  • 程序控制语句

  • 错误处理

  • 包相关

  • 基本类型

  • 变量引用

  • 保留关键字

注释

注释语法

支持单行、多行注释，编译器会忽略注释。
编译器还会忽略空白行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class HelloWorld {
    public static void main(String[] args) {
        // 单行注释方法一

        /* 单行注释方法二 */

        /* 多行注释
         * 多行注释
         */

         /**
          * 多行注释
          */
        System.out.println("Hello World");
    }
}

注释规范

  1. 类注释

每个类前面必须加类注释，模板：

1
2
3
4
5
6
7
8
9
/**
* Copyright (C), 2006-2010, ChengDu Lovo info. Co., Ltd.
* FileName: Test.java
* 类的详细说明
*
* @author 类创建者姓名
* @Date    创建日期
* @version 1.00
*/
  1. 属性注释

每个属性前面必须加属性注释，模板：

1
2
/** 提示信息 */
private String strMsg = null;
  1. 方法注释

每个方法前面必须加方法注释，模板：

1
2
3
4
5
6
7
/**
* 类方法的详细使用说明
*
* @param 参数1 参数1的使用说明
* @return 返回结果的说明
* @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明
*/
  1. 构造方法注释

每个构造方法前面必须加构造方法注释，模板：

1
2
3
4
5
6
/**
* 构造方法的详细使用说明
*
* @param 参数1 参数1的使用说明
* @throws 异常类型.错误代码 注明从此类方法中抛出异常的说明
*/
  1. 方法内部注释

在方法内部可以根据实际情况注释，模板：

1
2
//背景颜色
Color bgColor = Color.RED

继承

java可以使用继承来重用已存在的类，被继承的类称之为超类，派生出来的类称之为子类。

接口

java中的接口可以理解我对象之间相互通信的协议。

关于Java的编译运行

由图可见， .java 源文件经过编译后生成 .class 字节码文件，然后交由JVM解释运行。
故而从性能而言，java还是不如c/cpp这些编译型语言。

对象和类

java的基本概念：

  • 封装
  • 继承
  • 多态
  • 抽象
  • 类
  • 对象
  • 实例
  • 方法
  • 重载

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

对象

对象就是类的实例，有自己的属性和方法。

类

类就是对象的模板，是对对象的抽象。

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Dog{
  String breed;
  int age;
  String color;
  void barking(){
  }
 
  void hungry(){
  }
 
  void sleeping(){
  }
}

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

构造方法

每个类都有构造方法，如果没有定义则编译器会自动提供一个默认的构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

实例：

1
2
3
4
5
6
7
8
public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

创建对象

对象是由类创建的。

如何创建对象？
使用关键字 new 创建新对象：

  1. 首先声明一个对象。
  2. 使用new创建对象。
  3. 初始化对象。
1
2
3
4
5
6
7
8
9
10
public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

访问对象变量和方法

1
2
3
4
5
6
/* 实例化对象 */
Puppy myPuppy = new Puppy( "tommy" );
/* 访问类中的变量 */
myPuppy.age;
/* 访问类中的方法 */
myPuppy.barking();

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
 
   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 ); 
   }
}

运行：

源文件声明规则

  • 一个源文件只能有一个public类。
  • 一个源文件可以有多个非public类。
  • 源文件名要和public类名相同。
  • 如果一个类定义在某个包中，那么package语句要在源文件首行。
  • 如果源文件包含import语句，import应该放在package语句和类定义之间。如果没有package语句则import要放在源文件最前面。
  • import和package对源文件中定义的所有类都有效，在同一源文件中，不能给不同的类不同的包声明。

类有若干种访问级别，并且类也分不同的类型：抽象类和 final 类等。
还有特殊的类比如内部类和匿名类。

java包

包用来对类和接口分类。

import

实例：下面代码将会使编译器载入 java_installation/java/io 路径下的所有类。

1
import java.io.*;

实例

现在创建两个类：Employee和EmployeeTest，Employee类没有主函数，EmployeeTest有主函数。这里EmployeeTest调用了Employee的属性和方法。

Employee.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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);
   }
}

EmployeeTest.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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();
   }
}

编译运行：

1
2
javac EmployeeTest.java
java EmployeeTest

运行结果：

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

基本数据类型

变量就是用来存储数据的，java创建变量的时候会向内存申请空间。
内存管理系统根据变量的类型为其分配内存空间，改内存空间仅能用于存储改类型的数据。

实例：

1
2
// 申请一个内存空间，类型为int，并将数字7存入
int x = 7;

java两大数据类型：

  • 内置数据类型
  • 引用数据类型

内置数据类型

java内置了8中基本数据类型，其中有6种数字数据类型（4个整型+2个浮点型），一个字符数据类型，一个布尔型。

  1. byte

byte类型是8位、有符号、二进制补码表示的整数。
最小值是-128（-2^7），最大值是127（2^7-1），默认值为0。
byte类型的用处是节约空间，因为byte类型的空间占用只有int类型的1/4，主要是代替整数。

实例：

1
byte a = 3;
  1. short

short类型是16位、有符号、二进制补码表示的整数。
最小值是-32768（-2^15），最大值是32767（2^15 - 1），默认值为0。
一个short变量的空间占用是int类型的1/2。

实例：

1
short s = 1000;
  1. int

int类型是32位、有符号、二进制补码表示的整数。
最小值是-2, 147, 483, 648（-2^31），最大值是2, 147, 483, 647（2^31 - 1），默认值为0。
一般整型变量默认为int类型。

实例：

1
int a = 10000;
  1. long

long类型是64位、有符号的、二进制补码表示的整数。
最小值是-9, 223, 372, 036, 854, 775, 808（-2^63），最大值是9, 223, 372, 036, 854, 775, 807（2^63 -1），默认值为0L。
long类型主要是用在对于数字需求比较大的系统上。

实例：

1
2
// 大小写皆可，不过为了区分它和1，建议采用大写的L
long a = 100000L;
  1. float

float类型是单精度、32位、符合IEEE754标准的浮点数。
float在存储大型浮点数组的时候可以节省内存空间。
默认值为0.0f。
浮点数不能用于表示精确的值。

实例：

1
float f1 = 234.5f;
  1. double

double类型是双精度的、64位、符合IEEE754标准的浮点数。
浮点数默认类型为double类型。
double也不能表示精确的值。
默认值0.0d

实例：

1
double d1 = 123.4;
  1. boolean

boolean类型是表示一个比特的信息。
boolean取值只有 true 和 false 。
默认值 false 。

实例：

1
boolean opened = true;
  1. char

char类型是一个单一的16位unicode字符。
最小值 \u0000 （即为0），最大值 \uffff （即为65, 535）。
char类型可以存储任意字符。

实例：

1
char words = 'this';

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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

java中各个类型的默认值：

默认值

实例：输出各个数据类型的默认值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test {
    static boolean bool;
    static byte by;
    static char ch;
    static double d;
    static float f;
    static int i;
    static long l;
    static short sh;
    static String str;
 
    public static void main(String[] args) {
        System.out.println("Bool :" + bool);
        System.out.println("Byte :" + by);
        System.out.println("Character:" + ch);
        System.out.println("Double :" + d);
        System.out.println("Float :" + f);
        System.out.println("Integer :" + i);
        System.out.println("Long :" + l);
        System.out.println("Short :" + sh);
        System.out.println("String :" + str);
    }
}

输出：

Bool     :false
Byte     :0
Character:
Double   :0.0
Float    :0.0
Integer  :0
Long     :0
Short    :0
String   :null

引用类型

引用类型指向一个对象，指向对象的变量是引用变量。
这些变量在声明的时候被指定为一个特定类型比如Puppy等等，一旦声明就不能改变。

对象、数组都是引用数据类型。

所有引用类型默认值都是 null 。

一个引用变量可以用来引用任何与之兼容的类型。

实例：

1
Site site = new Site("cool");

常量

常量也就是不能被修改的量。

如何定义常量？
使用 final 关键字修饰常量：

1
final double PI = 3.1415;

正如上面缩写，常量名为了便于识别一般使用全大写。

字面量

字面量：其实，字面量的意思就是“字面上的量”，比如java中的一个数字 66 就是一个字面量，还有 "this is a line of string!" 就是一个字面量，还比如 true 和 false 也是字面量。

字面量表示的是如何表达一个值，所以在声明并赋值变量的时候，赋值符号 = 后面的 ; 前面的就是字面量。

byte, int, long, short都可以用十进制、八进制、十六进制表示。
前缀 0 表示八进制，前缀 0x 表示十六进制。
实例：

1
2
3
int decimal = 100;
int octal = 0144;
int hexa =  0x64;

java的字符串字面量是由两个引号包裹的字符串：

1
2
3
"Hello World"
"two\nlines"
"\"This is in quotes\""

除此之外，字符串还可以包含任意unicode字符：

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

转义字符：

换行： \n

回车： \r

换页符： \f

退格： \b

空字符： \0

空格： \s

制表符： \t

双引号： \"

单引号： \'

反斜杠： \\

八进制字符： \ddd

16进制unicode字符： \uxxx

类型转换

整型、常量、字符型数据可以混合运算。
转换从低级到高级。

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

数据类型转换规则：

  • 对boolean类型不能转换。
  • 不能将对象类型转换为不相关类的对象。
  • 将容量大的类型转换为小容量的类型的时候需要使用强制类型转换。
  • 转换可能导致数据溢出或者精度损失。
  • 浮点数转换到整数是通过舍弃小数得到的。

实例：

1
2
3
4
5
6
7
8
9
// 声明一个int型变量i并赋值128
int i = 128;

// 对i进行强制类型转换为byte型，因为byte最大值为127，故而强制类型转换会导致溢出
byte b = (byte)i;

// 浮点数转换为整数
(int)12.3 == 12;
(int)-45.89f == -45

自动类型转换

规则：转换前的数据类型的位数要低于转换后的数据类型。

实例：

1
2
3
4
5
6
7
8
9
10
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

上面字符对应的数字要查ASCII码。

强制类型转换

规则：转换的数据类型必须兼容。

格式：新类型 新变量名 = (新类型)旧变量名
比如： byte b = (byte)a;

实例：

1
2
3
4
5
6
7
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

隐含强制类型转换

  • 整数的默认类型是int
  • 浮点型不存在隐含强制类型转换，因为定义float/double的时候必须在浮点数后面加上f/F或者d/D。

Day01: 2020.09.04

喜欢这篇文章？打赏一下作者吧

评论

关注我

链接

分类

最新文章

归档

标签

二分查找1
二叉树1
二维数组1
动态规划2
双指针1
字符串1
排序1
数学1
数组3
树1
递归2
链表2

订阅更新

×