Select a result to preview

Java基础语法

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

基本语法

基础概念

Java 标识符

Java修饰符

Java 变量

Java注释

public class HelloWorld {
   /* 这是第一个Java程序
    * 它将输出 Hello World
    * 这是一个多行注释的示例
    */
    public static void main(String[] args){
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Hello World"); 
    }
}

Java 源程序与编译型运行区别

image.png

对象和类

创建对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

public class hello {
    public hello(String name){
        //这个构造器仅有一个参数：name
        System.out.println("小狗的名字是 : " + name ); 
     }
    public static void main(String[] args){
        hello A = new hello("xiaohai");
    }
}

我们有个叫hello的类，这个类里面有个构造函数需要一个参数name，我们new了一个对象，把这个对象命名为A，这个对象的name属性叫做xiaohai

源文件声明规则

import 语句

下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类

import java.io.*;

基本数据类型

java的数据类型包括两种

内置数据类型

byte：

short：

int：

long：

float：

double：

boolean：

char：

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

引用类型

Java 常量

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似

final double PI = 3.1415927;

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用字面量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制

Java 变量类型

type identifier [ = value][, identifier [= value] ...] ;

Java 语言支持的变量类型有：

public class RunoobTest {
    // 成员变量
    private int instanceVar;
    // 静态变量
    private static int staticVar;
    
    public void method(int paramVar/*参数变量*/) {
        // 局部变量
        int localVar = 10;
        
    }
    
    public static void main(String[] args) {
        RunoobTest v = new RunoobTest();
        v.method(20);
    }
}

Java 修饰符

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

非访问修饰符

Java 运算符

Java 循环结构

for, while 及 do...while

Java switch case 语句

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

Java Number

然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类**（Integer、Long、Byte、Double、Float、Short）**都是抽象类 Number 的子类。

Java Math 类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public class Test {  
    public static void main (String []args)  
    {  
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值：" + Math.cos(0));  
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值： " + Math.atan(1));  
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);  
    }  
}

Java String 类

如何创建

String str = "Runoob";

或者

String str2=new String("Runoob");

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

Java StringBuffer和 StringBuilder 类

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。

StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

Java 数组

创建数组

int[] A = new int[10];

处理数组的时候可以使用For-Each 循环

for(type element: array){
    System.out.println(element);
}

数组可以作为参数传递给方法

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}
printArray(new int[]{3, 1, 2, 6, 4, 2});

数组也可以作为函数的返回值

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

多维数组

String[][] str = new String[3][4];

Arrays 类

ava.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

Java 方法

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

命令行参数的使用

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

命令行参数是在执行程序时候紧跟在程序名字后面的信息。

public class CommandLine {
   public static void main(String[] args){ 
      for(int i=0; i<args.length; i++){
         System.out.println("args[" + i + "]: " + args[i]);
      }
   }
}

这样在编译的时候就会跟在后面了

可变参数

typeName... parameterName

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
 
        double result = numbers[0];
 
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }

finalize() 方法

析构函数，在对象被回收之前调用

protected void finalize()
{
   // 在这里终结代码
}

Java 流(Stream)、文件(File)和IO

读取控制台输入

我们首先需要创建一个BufferedReader，把System.in 封装在里面

BufferedReader br = new BufferedReader(new 
                      InputStreamReader(System.in));

想要读取一个字符就需要使用read()方法

每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回。 当流结束的时候返回 -1。该方法抛出 IOException。

//使用 BufferedReader 在控制台读取字符
 
import java.io.*;
 
public class BRRead {
    public static void main(String[] args) throws IOException {
        char c;
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入字符, 按下 'q' 键退出。");
        // 读取字符
        do {
            c = (char) br.read();
            System.out.println(c);
        } while (c != 'q');
    }
}

从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法。

String str=br.readLine()

控制台输出

println

读写文件

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

InputStream f = new FileInputStream("C:/java/hello");

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

File f = new File("C:/java/hello"); InputStream in = new FileInputStream(f);

使用字符串类型的文件名来创建一个输出流对象：

OutputStream f = new FileOutputStream("C:/java/hello")

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

File f = new File("C:/java/hello"); OutputStream fOut = new FileOutputStream(f);

当然我们也可以是用Scanner来输入

需要调用java.util.Scanner

Scanner scan = new Scanner(System.in);

有两个操作，next和nextLine

nextLine可以有空格，读整行