Java初级语法笔记

教程地址：https://www.runoob.com/java/java-tutorial.html

Java 修饰符

访问控制修饰符

• default
  • 变量：public static final
  • 方法：public
• public
• protect
• private

非访问类修饰符

• static：静态方法 静态变量
• final：变量 方法 类
• abstract：抽象类，具体方法子类实现
  • 包含抽象方法的类必须声明为抽象类
• synchronized：声明的方法同一时间只能被一个线程访问。
• transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
• volatile：volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

//volatile example
public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

Java 运算符

• 算术运算符
• 关系运算符
• 位运算符
  • ~取反
  • >>>右移补0

Java 基本数据类型

枚举（Enumeration）
位集合（BitSet）
向量（Vector）
栈（Stack）
字典（Dictionary）
哈希表（Hashtable）
属性（Properties）

Number类和Math类

• x.intValue()
• valueOf(string)

Character类和String类

• String类初始化后就不可改
• String.format(’%f’,floatVar)

StringBuffer类和StringBuilder类

• StringBuffer
  • SB.append(String s)

Java 数组

forEach循环

public class test{
	public static void main(String[] args){
		int[] arr={1,2,3,4,5,6}
		for (int i:arr){
			//遍历访问arr的元素
		}
	}
}

Java 休眠

sleep()：阻塞当前线程

Java 正则表达式

import java.util.regex.*;
 
class RegexExample1{
   public static void main(String args[]){
      String content = "I am noob " +
        "from runoob.com.";
 
      String pattern = ".*runoob.*";
 
      boolean isMatch = Pattern.matches(pattern, content);
      System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);
   }
}

Java 函数

• @override 重写修饰符
  • super 指代父类
• @overload

可变参数
typeName... parameterName

public static void printMax( int... numbers) {}

finalize()方法

• 回收对象清除
• 对象销毁之前

Java IO

java.io 控制输入输出流

//使用 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 {
        	// (char)的目的：返回值为输入的整数值，将其转化为char
            c = (char) br.read();
            System.out.println(c);
        } while (c != 'q');
    }
}

文件系统
File class
FileReader class
FileWriter class

Java 异常处理

抛出异常

import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

捕获异常

try{
	//statements
}catch(Exception1 e){
	//异常处理1	
}catch(Exception2 e){
	//异常处理2
}finally{
	//无论是否发生异常，finally 代码块中的代码总会被执行。
}

Java 类继承

关键字：extends

public class Penguin extends Animal{
	    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

关键字：implements（接口类的多继承）

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

Java Interface(接口类)

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

接口之间的相互继承关系使用关键字extends

Java package

//example.java
package pkg1[.pkg2[.pkg3...]]

包名 com.chaoszh.example
对应路径 com/chaoszh/example/example.java

包引用

import package_name //按需引入
import package_name.object_name //引入包中的某个对象

按需类型导入( import java.io.*; )，有人误解为导入一个包下的所有类，其实不然，看名字就知道，他只会按需导入，也就是说它并非导入整个包，而仅仅导入当前类需要使用的类。

编译相关

• class path 类目录

Java 集合框架

集合框架——指的是数组的衍生类，无外乎探讨的是一组数据存储的多种方式。

• 集合 Collection
  • List
  • Set
  • Queue
• 图 Map
• 等等

Java 泛型

泛型方法

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

通过以上代码可以显然看出，java所定义的泛型实际上就相当于c++的模板类。
模糊指定的E作为一个在定义阶段尚且不明晰的数据类型，而在实际调用方法时才确定下来。

泛型类

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

类型通配符

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

没能体会到其与泛型方法的差别。

Java 序列化/反序列化

简而言之，序列化就是将一个java对象输出，并用文件的形式保存下来；反序列化就是将一个java对象从文件中读取，并重新初始化为一个java内部可以直接调用的对象。

• ObjectOutputStream 类用来序列化一个对象
• ObjectInputStream 类用来反序列化一个对象
• 当序列化一个对象到文件时， 按照 Java 的标准约定是给文件一个 .ser 扩展名。

Java 网络编程

Socket编程

java.net中提供了两个类：

1. Socket可用于创建一个套接字；
2. ServerSocket类为服务器程序提供了一种来监听客户端。

Java 多线程编程

略

Java Applet基础

Applet 是一种 Java 程序。它一般运行在支持 Java 的 Web 浏览器内。因为它有完整的 Java API支持,所以Applet 是一个全功能的 Java 应用程序。

<html>
<title>The Hello, World Applet</title>
<hr>
<applet code="HelloWorldApplet.class" width="320" height="120">
If your browser was Java-enabled, a "Hello, World"
message would appear here.
</applet>
<hr>
</html>

可以看到上面的html代码调用了一个叫做HelloWorldApplet的class。

import java.applet.*;
import java.awt.*;
 
public class HelloWorldApplet extends Applet
{
   public void paint (Graphics g)
   {
      g.drawString ("Hello World", 25, 50);
   }
}

Java 文档注释

Java 支持三种注释方式。前两种分别是 // 和 /* */，第三种被称作说明注释，它以 /** 开始，以 */结束。
说明注释允许你在程序中嵌入关于程序的信息。你可以使用 javadoc 工具软件来生成信息，并输出到HTML文件中。
说明注释，使你更加方便的记录你的程序信息。

javadoc

javadoc的作用是：

1. 一个从程序中抽取注释生成对应的说明文档。
2. 写了javadoc后，在别人使用到你的jar包，鼠标悬停在对应类上会显示对应的提示信息

references：https://blog.csdn.net/vbirdbest/article/details/80296136
references：https://www.cnblogs.com/rever/p/8463816.html