public class helloWorlds {//定一个类 首字母小字后面单词首字母大写
    public static void main(String[] args) {//psvm main入口方法一个类只有一个
    int a=99;//定义类型为整数a的变量名赋值99的值
    a=88;//通过变量名找到内存值，重新赋值88
    a=a+1;//通过变量名a找到内存值88再+1计算89再赋值给a变量名
    System.out.println(a);//输入变量值
    }
}

 int score=59;//赋值int类型成绩 为59
    score+=1;//先加1算术运算，再赋值运算
    if (score>=60){//比较运算
        System.out.println("及格了");//控制输出结果分支
    }else {//如果。。就。。不然
        System.out.println("没及格");//控制输出结果分支
    }

顺序：程序从上到下顺序执行
选择：if else分支结构 如果..就..如果..就..不然 
循环whille 只要..一直

遍历List集合的三种方法
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
方法一：
超级for循环遍历
for(String attribute : list) {
  System.out.println(attribute);
}
方法二：
对于ArrayList来说速度比较快, 用for循环, 以size为条件遍历:
for(int i = 0 ; i < list.size() ; i++) {
  system.out.println(list.get(i));
}
方法三：
集合类的通用遍历方式, 从很早的版本就有, 用迭代器迭代
Iterator it = list.iterator();
while(it.hasNext()) {
  System.ou.println(it.next);
}

遍历map四种方法
 Map<String, String> map = new HashMap<String, String>();      
    map.put("key1", "val1");      
    map.put("key2", "val2");      
    map.put("key3", "val3");   
  
    //通过Map.entrySet遍历  
    for (Map.Entry<String, String> entry : map.entrySet()) {      
        System.out.println("key= " + entry.getKey() + " and val= " + entry.getValue());      
    }   
        
    //通过Map.keySet遍历  
    for (String key : map.keySet()) {      
        System.out.println("key= "+ key + " and val= " + map.get(key));      
     }  
    
    //通过Map.entrySet使用iterator遍历  
    Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();      
        while (it.hasNext()) {      
            Map.Entry<String, String> entry = it.next();      
            System.out.println("key= " + entry.getKey() + " and val= " + entry.getValue());      
        }    
    }  
    
    //通过Map.values()遍历  
    for (String v : map.values()) {      
        System.out.println("val= " + v);      
    }      

@Test
public void test(){//猜数字 游戏
	System.out.println("请输入你猜的数1-100之间：");
	Scanner sc= new Scanner(System.in);//扫描输入对象 会提示输入
	int n=new Random().nextInt(100);//产生100以内随机数字类型
	while (true) {	//一直循环运行
	int i=sc.nextInt();//创建int局部变量 输入的数
	if (i>n) {System.out.println("大了");//大了提示
	}else if (i<n) {System.out.println("小了");//小了提示
	} else {System.out.println("竟然猜中了");break;}	}//中了提示并退出
}

@Test
public void test(){//匹配用户名
	System.out.println("请输入用户名");
	Scanner sc= new Scanner(System.in);//扫描输入对象
	boolean b_username=Pattern.matches("\\w{4,16}",sc.nextLine());
	if (b_username) {
		System.out.println("用户名是4到16位字母不区分大小字和数字之间");
	}else{System.out.println("不匹配");}
}

[abc]{3,}中括号组单个字符:要么是a或b或c后面出现三次或以上
[^abc]{1,4} 非括号内的字符出现1-4次之间 [^3]* 不等于3后面任意长度
[a-zA-Z]内z-zAA-Z 所有单个字符 [^a-zA-Z]反之 非这些字符
.任意单个字符 .*前面任一个字符出现任意次 +一次或多次  ?前字符0次或一次
\预定义成匹配符或特殊: \\d or [0-9]任何0-9单个字符 \\D非 [^0-9]的其它单个字符
\\w 相当于[a-zA-Z0-9_] 范围的单个字符 \\W 反之 | 或者
\\s空白\\S反  \\t 制表 \\n换行 \\r回车 \\换页 \\b单词边界 ^行头 $行尾 \\ \\. \\*

(Pattern.matches("(ab(c))@\\1\\2", "abc@abcc"))分组成整体 再操作 ab小组然后cd然后引用第一小组规则再引用1再第二个小组(b)2次
(abc)+*\\1  abc字符封装成组再出现一次或多次 再任何字符 再引用第一组 

char[] arr={'s','h','o','p'};
String string2 = new String(arr);
System.out.println(string2);//打印shop
byte[]arr1={55,66};
String string = new String(arr1);
System.out.println(string);//打印7b

String string="333";
        int i = Integer.parseInt(string);
        System.out.println(i);//333
        double double1 = Double.parseDouble(string);
        System.out.println(double1);//333.0
        System.out.println(Float.parseFloat(string));//333.0

for (int i = 0; i < list.size(); i++) {
   System.out.print(list.get(i) + ",");
}

Iterator iterator = list.iterator();
while (iterator.hasNext()) {
   System.out.print(iterator.next() + ",");
}

for (Integer i : list) {
   System.out.print(i + ",");
}

长度固定 类型固定 存基本和引用数据类型 通过角标访问

```
声明一个数组String[]arr;初始化arr=new String[4];赋值arr[0]="";
简写:String[]arr=new String[4];
```



```
String[]array={"张三","李四","王五"};//快速初始化
array[0]="张小三";//赋值或更改 
System.out.println(array[0]);//查看第0个元素 张小三
System.out.println(array.length==0);//是否为空 false
```

返回新数组 return new int[]{arr[2],arr[1],arr[0]};

return new String[]{"钻石会员","黄金会员","白金会员","vip会员","普通"};

赋值/改 names[1]="李四四";

查 names[1]; // 李四

打印数组长度:System.out.println(names.lenght);

String[]arr={"张","李","王"};for(i=0;i<i.leng;i++){};i就是数组角标 角标少于长度时i++
增强for 获取容器每个元素:(容器中元素数据类型 起的变量名: 要遍历的容器名){使用变量};for(String string:arr){}; 变量名相当于"arr[i]"

System.arrarcopy(src,srcPos,dest,destPos,length);
1原数组 2从原数组的那个角标开始拷贝 3目标数组 4从目标数组的那个角标开始 5拷贝的个数

二维: int[][]arr={{1,2},{4,3}};
arr[0][1]; 获取arr二维数组中 第0个角标一位数组中 第1个角标元素2

Arrays.toString(arr) 转字符串 重写toString方法就查看对象属性和方法 要不然打印是内存址

Arrays.sort();数组元素排序

 List<String Integer只能是引用>list=Arrays.asList(arr)转成

​		List<String>custTypeList=Arrays.asList(new String[] {"钻石会员","黄金会员","白金会员","vip会员","普通"});

                  |-ArrayList 动态数组 可null 查快
          |-List -|-LinkedList链表 增删快
          |有序可重|-Vector ArrayList相似 多线程安全
Collection|       
          |     |-HashSet 以哈希表的形式存放元素，插入删除速度很快
          |-Set-|-LinkedHashSet 集合迭代时，维护插入顺序
         无序不重|-TreeSet 升序排好序的集合
         
Map（键值对、键唯一、值可不唯一 以键map.get(key)）
   |-HashMap 快速 线程不安全 键可一个null  散列表的通用映射表，无序
   |-HashTable HashMap相似 线程安全 较慢 不可Null  
Map|-LinkedHashMap 保存了记录的插入顺序 Iteraor遍历时先进先出
   |-TreeMap 根据键升序排序 可指定比较器

 Set<String> strings = new HashSet<>();
        strings.add("张三"); strings.add("李四"); strings.add("王五");
        System.out.println(strings.contains("张三"));//true
        for (Iterator iterator=strings.iterator();iterator.hasNext();){
            System.out.println(iterator.next());
        }
        for (String string1 : strings) {
            System.out.println(string1);
        }

HashMap<Integer,String> map = new HashMap<>();
map.put(1, "张三");map.put(2, "李四");//增加两个键值对
map.put(1, "王五");//通过键更改值
map.remove(0);//通过键删除这个键值对
map.size() 获取集合长度
map.isEmpty()判断是否为空
System.out.println(map.get(1));//通过键拿到value"张三"
Collection<String> values = map.values();//拿到的值的集合
System.out.println(map);//打印map {1=张三,2=李四}

不能直接for遍历 map.keySet(); map.entrySet();添加到其它集合
Set<String>set=map.keySet();//把map通过keySet方法存入set
for (String k : set) {//遍历set集合 拿到键 并打印键和值 
System.out.println(k+map.get(k));}
优化:for (String k : map.keySet()) {System.out.println(k+map.get(k));}

Set<Entry<String,Integer>>set=map.entrySet(); //把map用entrySet方法加入set集合 
for (Entry<String,Integer>en :set) {//遍历set 拿到键和值
System.out.println(en.getKey()+en.getValue());}//打印键和值
优化:for (Entry<String,Integer>en :map.entrySet()) {
System.out.println(en.getKey()+en.getValue());}

values():Collection<String>col=map.values();以Collection集合 拿到所有值
 <Collection和Set集合 和ArrayList基本一样 无索引只能遍历>

HashSet<String>set=new HashSet<>();总是以哈希 顺序排序的集合 无索引无序无重复

Properties p=new Properties(); //双列集合写到配置文件 
p.setProperty("name","zhangshang");//把元素添加到集合不能中文
FileOutputStream fos=new FileOutputStream("1.txt");p.store(fos, null);//写出到文件
FileInputStream fis=new FileInputStream("1.txt");p.load(fis);//从文件读到集合

ArrayList<Integer>list=new ArrayList<>();//快速初始化为泛型 有序先进先出
list.add(4);list.add(3);list.add(2);list.add(1);//新增加到尾部
list.set(3, 33);//更改第3个角标为33
System.out.println(list.remove(0));//删除第0个角标4
System.out.println(list.get(0));//通过角标查看第0个 3
System.out.println(list.isEmpty());//是否为空 false
System.out.println(list);//可直接打印[43,2,33]

@Test
    public void fun01(){
    	Map<String,String> map = new HashMap<>();
       map.put("name", "小小");map.put("age", "18");
       System.out.println("map="+map);//map={age=18, name=小小}
    }
    @Test
    public void fun02(){
    	ArrayList<String> list = new ArrayList<>();
    	list.add("小明");list.add("小红");
    	System.out.println("list="+list);//list=[小明, 小红]
    }
    @Test
    public void fun03(){
    	String[] array = new String[2];
    	array[0]="小明";array[1]="小红";
    	System.out.println("array="+Arrays.toString(array));//array=[小明, 小红]
    }

打印指定目录格式的文件
//调用new File("e:/"),".txt");
static void (File file,String str) {
File[] fl=file.listFiles();//以文件对象数组接收
for (File file0 : fl) {//遍历fl对象并.txt结尾
if (file0.isFile()&&file0.getName()
.endsWith(".txt")) {System.out.println(file0);}}}

deletefile(new File("c:/a"));}删除指定文件(夹)
public static void deletefile(File file) {
File[] fl=file.listFiles();//把文件对象装进数组
for (File file2 : fl) {//循环每一个
if (file2.isFile()) {//如果是文件就删除
file2.delete();//就删除
}else if (file2.isDirectory()) {//如果是文件夹
deletefile(file2);}}//递归调用此方法
file.delete();}//根目录和没有文件的目录删除

public static void main(String[] args) {
cat c=new cat("猫", "白色");
dog d=new dog("狗", "黑色");
animal a=new animal("动物");
eat(d);}//黑色狗吃饭
public static void eat(animal a) {
a.eat();//如果传a就动物吃饭
if (a instanceof cat) {
cat c=(cat) a;//如果a是cat类型就转为cat
}else if (a instanceof dog) {
dog g=(dog) a;	}}//如果a是dog类型就转为dog

继承Thread类共享100张票可以用静态变量 只会执行一次   private start int ticket=100; 
也可以实现 Rannable接口里类 再在演示里开几个线程也可同时共享100张票
private static int ticket=100; 演示类里多几个线程共享此变量 new TicketDemo().start();
public void run() {while (true){if (ticket>0) {System.out.println("卖票"+ticket--);}else {break;}}}
最好接口public class TicketDemo implements Runnable {private int ticket=100;
public void run() {while (true) {if (ticket>0) { //多线程共享new TicketDemo().start(TicketDemo);
System.out.println(Thread.currentThread().getName()+"卖票"+ticket--);}else {break;}}}}

class person extends Thread{
public void run() {//同步代码块
synchronized ("person.class 锁对象") {
System.out.println(name+"1步骤");
System.out.println(name+"2步骤);}}

public class Test1 {
	@Test
public void fun() throws IOException{// 字节 byte数组方式读写 操作非文字文件
FileInputStream fis = new FileInputStream("a.txt");// 字节输入流对象  在本项目下要有a.txt 非rec
FileOutputStream fos = new FileOutputStream("c:/b.txt",true);// 字节输出流到c盘b.txt 追加
byte[] arr = new byte[8196];//创建byte数组一次读多少字节
int len;// 声明一个int 用来存储读取到的字节数据
while ((len = fis.read(arr)) != -1) {//如果fis读到arr数组的len个数不等于-1
fos.write(arr,0,len);//就一直写 以arr数组从0开始到len结束
}fis.close();	fos.close();//关流	
}
@Test
public void fun2() throws IOException{// 高速缓冲字节输入输出
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("a.txt"));//高速缓冲输入流对象  在本项目下要有a.txt 非rec 
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("c.txt"));//高速缓冲输出流   
int len;//定义一个int变量 用来存储读取到的字节数据
while ((len=bis.read())!=-1) {//循环bis对象读取数据,并赋给len 并和-1判断 到最后为止
bos.write(len);}bos.close();bis.close();//把合格的len 写到bos	
}

@Test
public void fun3() throws IOException{// 用字符数组输入输出 操作文字文件
FileReader fr=new FileReader("a.txt");//字符输入流对象
FileWriter fw=new FileWriter("b.txt");//字符输出流对象
char[]arr=new char[1024*8];//定义字符数组 存储读取的字取并指定长度4
int len;//定义一个变量用来存储读取的有效 字符数
while ((len=fr.read(arr))!=-1) {//循环读数据存储到字符数中并返回有效
fw.write(arr,0,len);//字符数组chs 从0到len 写入到fw
}fr.close();fw.close();//关流 //
}
@Test
public void fun4() throws IOException{// 用高速缓存字符数组输入输出
BufferedReader br=new BufferedReader(new FileReader("a.txt"));//高速字符输入流对象
BufferedWriter bw=new BufferedWriter(new FileWriter("b.txt"));//高速字符输出流对象
int len;
while ((len=br.read())!=-1) {
bw.write(len);
}br.close();bw.close();
//while ((s=br.readLine())!=null)只要高速缓存字符流可读取文本中的一行:
}

@Test
public void fun5() throws IOException{// 下载流
java.io.InputStream is=new URL("http://localhost/b.txt").openStream();//www.b.com/index.html
FileOutputStream fos = new FileOutputStream("fF.txt");// 字节输出流
byte[] arr = new byte[1024 * 8];//创建byte数组一次读多少字节
int len;// 声明一个int 用来存储读取到的字节数据
while ((len = is.read(arr)) != -1) {//如果fis读以arr数组一次读没有到最后字节
fos.write(arr,0,len);//就一直写 以arr数组从0开始到len
}is.close();	fos.close();//关流
}

public class Test0 {
public static void main(String[] args) {
printfiles(new File("h:/新建文件夹"));//调用递归删除方法 传File对象 不要传盘符有很多隐藏会空指针
	}
static void printfiles(File file) {  //递归删除方法
	File[] fl=file.listFiles();//用文件对象数组fl接收该对象目录下所有
	for (File file2 : fl) {//遍历 所有文件和文件夹的文件对象数组
	if (file2.isFile()) {//如果是文件
	file2.delete();//就删除
	}else if(file2.isDirectory()) {//如果是文件夹
	printfiles(file2);	}}//递归 传file2 删除文件夹中的文件值到全删光
	file.delete();System.out.println("指定的文件对象全删光");}//最后删除文件夹

package 反射;//包
public class Person {//学生 类
public String name;//声明姓名属性/全局变量 公共装饰权限
private int age;//声明年龄属性/全局变量 私有装饰权限 
public Person(String name, int age) {//有参构造 
	this.name = name;
	this.age = age;}
public Person() {}//无参构造 

public void eat() {
	System.out.println(name+"学生类 吃饭的无参无返回公共方法");
}
public void work(String name) {
	System.out.println(name+"学生类 工作的有参无返回 公共方法");
}
private void sleep(int num) {
	System.out.println("学生类"+ name+num+"睡觉的无参有返回私有方法");
}
@Override
public String toString() {
	return "Person [name=" + name + ", age=" + age + "]";
}}

package 反射;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.junit.Test;
public class Test0 {//演示反射
public static void main(String[] args) throws Exception {
	Class clazz = Class.forName("反射.Person");//通过类全限定名获取
Class clazz1 =Person.class;//通过字节码文件阶段获取
Class clazz2 = new Person().getClass();//通过对象获取
System.out.println(clazz==clazz1&&clazz1==clazz2);//true

Person p = (Person) clazz.newInstance();//使用空参构造 创建对象
System.out.println(p);//Person [name=null, age=0]打印的是tostring

Field f_name = clazz.getField("name");//反射得到公共成员变量
f_name.set(p, "李四");//使用这 变量为p对象中成员变量赋值 
System.out.println(p);//p对象成员变量有值了 Person [name=李四, age=0]

Field a_name = clazz.getDeclaredField("age");//暴力反射得到私有成员变量
a_name.setAccessible(true);//去除私有权限
a_name.set(p, 33);//使用这 变量为p对象中成员变量赋值 
System.out.println(p);//p对象成员变量有值了 Person [name=李四, age=33]
p.eat(); //李四学生类吃饭的无参无返回公共方法

Constructor c = clazz1.getConstructor(String.class, int.class);//先创建Constructor/构造对象 参数传 参数类型.class
Person p2 = (Person) c.newInstance("张三",22);//使用有参构造 创建对象
System.out.println(p2);//Person [name=张三, age=22]
p2.eat();//也可以调公共方法了 张三学生类吃饭的无参无返回公共方法
p2.work("王五"); //王五学生类 工作的有参无返回 公共方法 

clazz.getMethod("work", String.class).invoke(p2, "六麻子"); //共公有参方法有对象直接可以调不需要反射

Method sleep=clazz.getDeclaredMethod("sleep", int.class);//暴力反射得到私有方法 参数传方法名和 参数类型.class
sleep.setAccessible(true);//去除私有权限
sleep.invoke(p2, 12);//学生类张三12睡觉的无参有返回私有方法 调用p2私有方法 传参数

Method[] methods = clazz1.getDeclaredMethods();//还可以一次性获得所有方法的数组
for (Method method : methods) {//遍历所有方法的数组
	method.setAccessible(true);//去除限制 
	if (method.equals("sleep")) {//如果有个方法等于睡觉
		method.invoke("sleep", "越六");//就执行 //学生类张三12睡觉的无参有返回私有方法
}	}}

long t1 = System.currentTimeMillis();//当前时间毫秒值t1  下面代码获得当前时间戳并格式化为那种
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
//String format = new SimpleDateFormat("yyyy年MM月dd日  HH时mm分ss秒").format(new Date());
long t2 = new Date().getTime();//当前时间毫秒值 t2
System.out.println(t2-t1);//打印 运行中间代码需要的毫秒值

单例
public class Test {
	private int ticket=100;
	private Test(){}//私有化构造
	public static class SingleIstance{//静态内部类
		public static Test INSTANCE=new Test();//在内部类创建单例 INSTANCE对象
	}
	public static Test getInstance(){//向外提供静态获取单例对象
		return SingleIstance.INSTANCE;
	}
}

package test;
import java.util.Arrays;
public class demo {
/**
 * 快速排序:定义两个下标leftIndex rightIndex,定义一个基准数base(默认是第一个元素),从右边开始,找到一个小于基准的数就停止,从左边开始,找到一个大于基准的数停止,如果此时左右下标的没有交叉,交换左右下标的值,继续寻找,直到交叉,就交换右下标和基准数的值,得到右下标将数据分两半,左半部分<右下标的值<右边部分,递归找左边部分中间位置直到中间数是在中间位置,递归找右边部分中间位置直到中间数在中间位置,排序完成.
 * 第一个元素定为基准元素,通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值均比基准值大,此时基准元素在其排好序后的正确中间位置,然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。
 */
public static class QuickSort {
    public static void quickSort(int[]arr,int startIndex,int endIndex){//调此方法需 数组 开始下标[0] 结束下标[arr.length-1]
int leftIndex,rightIndex,base,temp;//声明变量:左下标 右下标 基准数 临时来用交换数
if(startIndex>endIndex){//递归停止条件是 开始下标 大于结束的
    return;	   }
    
leftIndex=startIndex;//左下标为调用的第一个元素
rightIndex=endIndex;//右下标为调用的最后一个元素
base = arr[startIndex];//基准数为第一个元素6 [6 1 2 7 9 3 4 5 10 8]
while (leftIndex<rightIndex) {//左下标小于右下标就一直循环  到交叉了就停止
    while (base<=arr[rightIndex]&&leftIndex<rightIndex) {//基准数还少于等于右下标数并且左下标小于右下标
        rightIndex--;//从右边开始6和8比，依次往左递减1 少于6的是5的位置停止
    }
    while (base>=arr[leftIndex]&&leftIndex<rightIndex) {//基数大于左下标数并且 左下标小于右下标
        leftIndex++;//再左边开始6和6比，依次往右递增1 大于6的是7的位置停止
    }
    if(leftIndex<rightIndex) {//只要 左下标还少于右下标就 交换左右下标值5和7 [6 1 2 5 9 3 4 7 10 8]
        temp = arr[rightIndex];
        arr[rightIndex] = arr[leftIndex];
        arr[leftIndex] = temp;
    }//[3,1,2,5,4,6,9,7,10,8]
}//base基数现在在中间了,此时以基准数6为分界点，6左边的数都小于等于6，6右边的数都大于等于6, 
 arr[startIndex] = arr[leftIndex];//现在再将左下标值和开始下标交换基准数和左下标数交换 
 arr[leftIndex] = base;//交换后左边的序列是3  1  2 5  4右边9  7  10  8 分两部分调用本方法
quickSort(arr, startIndex, rightIndex-1);//递归左半部分 直到基数在中间位置 左边以第一元素为起点以右下标-1位置为最后
quickSort(arr, rightIndex+1, endIndex); //递归右半部分 右下标+1位置为起点以最后下标最后
}

public static void main(String[] args) {//调用测试
	        int[] arr = {6,1,2,7,9,3,4,5,10,8,-9};
	        quickSort(arr, 0, arr.length-1);
	            System.out.println(Arrays.toString(arr));
	    }
}
}

import java.util.Arrays;
public  class demo {
public static void main(String[]args) {
    int[] arr = {5,88,0,66,2,9,-8};
    System.out.println("排序前"+Arrays.toString(arr));
   System.out.println("从小到大排序后"+Arrays.toString(sort2(arr)));
}
    public static int[] sort2(int[]arr){
        //外层循环0角标开始 控制总次数
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {//内循环 每比较一次长度就-1-i这样每比较目前最大的数总在最后
                if (arr[j]>arr[j+1]) {//每循环一次 如果前一个元素大于后一个 互换
                    int temp=arr[j];//先把arr[j]给临时
                    arr[j]=arr[j+1];//互换
                    arr[j+1]=temp;
                }
            }
        }
        return arr;
    }
}

public void sort2(int[]arr) {
	    for(int i=1;i<arr.length;i++){  
	    	int temp=0;  
	       int j=i-1;  
	       temp=arr[i];  
	     for(;j>=0&&temp<arr[j];j--){  
	       arr[j+1]=arr[j];//将大于temp的值整体后移一个单位  
	       }  
	       arr[j+1]=temp;  
	    }  
	}

public class 小孩类 extends 人类 {
  String 想做的事 = "大人的事";

  public 小孩类(String 姓名, int 年龄) {
    super(姓名, 年龄);
  }

  public void 长大() {
    System.out.println("我要做" + 想做的事);
  }
}

class 问好 {
  public static void main (String[] 参数) {
    // 待续: 要让它做的事
  }
}

class 问好 {
  public static void main (String[] 参数) {
    // 要让它做的事
    System.out.println("吃了么");
  }
}

吃了么

$ javac 问好.java

$ javac -encoding utf8 问好.java

$ java 问好

class 四则运算 {
  public static void main (String[] 参数) {
    System.out.println(1+2);
  }
}

class 根号 {
  public static void main (String[] 参数) {
    System.out.println(Math.sqrt(4));
  }
}

    System.out.println("4的平方根是" + Math.sqrt(4));

    int 数 = 4;
    System.out.println(数 + "的平方根是" + Math.sqrt(数));

    int 数 = Integer.parseInt(参数[0]);
    System.out.println(数 + "的平方根是" + Math.sqrt(数));

$ java 根号 4

class 随机数生成器 {
  public static void main (String[] 参数) {
    java.util.Random 生成器 = new java.util.Random();
    System.out.println("我想到的数字是:" + 生成器.nextInt());
  }
}

import java.util.Random;

class 随机数生成器 {
  public static void main (String[] 参数) {
    Random 生成器 = new Random();
    System.out.println("我想到的数字是:" + 生成器.nextInt());
  }
}

boolean 年纪尚幼 = true; // true或false,真或假
char 姓 = '好'; // 单个字符
byte 年龄 = 27; // 字节: -128到127, 即-2^7到(2^7-1)
short 认识人数 = 1234; // 短整数: -32768到32767, 即-2^15到(2^15-1)
int 不认识人数 = 1234567890; // 整数: -2^31到(2^31-1)
long 星球数 = 123456789000000000L; // 长整数: -2^63到(2^63-1)
float 身高 = 1100000000f; // 单精度浮点数: 2^-126到(2-2^-23)*2^127
double 体重 = 999999999999.9; // 双精度浮点数: 2^-1074到(2-2^-52)*2^1023

class 识字类 {
  public static void main (String[] 参数) {
    int 识字量 = 1;
    int 每年增倍数 = 2;

    // 第一年
    识字量 = (1 + 每年增倍数) * 识字量;

    // 第二年
    识字量 = (1 + 每年增倍数) * 识字量;

    // 第三年
    识字量 = (1 + 每年增倍数) * 识字量;
    System.out.println("三年后认识" + 识字量 + "个字咯");
  }
}

class 特殊字符 {
  public static void main (String[] 参数) {
    System.out.println("边检员看了看证件,头没抬地说\t\"这么久没回了啊?\".\n百感交集,咧着嘴回了一句\t\"是啊,还没完呢\"");
  }
}

class 字符串方法 {
  public static void main (String[] 参数) {
    String 字符串 = "去是go";
    String 搜索字符串 = "go";
    System.out.println("\"" + 字符串 + "\"的长度:" + 字符串.length());
    System.out.println(搜索字符串 + "在\"" + 字符串 + "\"的位置是:" + 字符串.indexOf(搜索字符串));
    System.out.println("\"" + 字符串 + "\"的第一个字符是:" + 字符串.charAt(0));
  }
}

if (年龄 < 20) {
  System.out.println("没到法定婚龄! 等几年再结婚吧");
} else {
  System.out.println("妹妹,真想嫁也拦不住你.要不再考虑一天?");
}

if (年龄 < 5) {
  System.out.println("这是哪家闺女啊?爸妈在哪儿呢?");
} else if (年龄 < 20) {
  System.out.println("没到法定婚龄! 等几年再结婚吧");
} else {
  System.out.println("妹妹,真想嫁也拦不住你.要不再考虑一天?");
}

if (年龄 < 20) {
  System.out.println("没到法定婚龄! 等几年再结婚吧");
} else if (年龄 < 5) {
  System.out.println("这是哪家闺女啊?爸妈在哪儿呢?");
} else {
  System.out.println("妹妹,真想嫁也拦不住你.要不再考虑一天?");
}

if ("辛苦".equals("不辛苦")) {
  System.out.println("辛不辛苦无所谓");
} else if ("辛苦".compareTo("不辛苦") > 0){
  System.out.println("辛苦点好");
} else {
  System.out.println("不辛苦好");
}

for (int 年份 = 0; 年份 < 年限; 年份 = 年份 + 1) {
  识字量 = (1 + 每年翻倍数) * 识字量;
}

int 年份 = 0;
while (年份 < 年限) {
  识字量 = (1 + 每年翻倍数) * 识字量;
  年份 = 年份 + 1;
}

int 年份 = 0;
while (年份 < 年限) {
  if (识字量 > 3000) {
    break;
  }
  识字量 = (1 + 每年翻倍数) * 识字量;
  年份 = 年份 + 1;
}
System.out.println(年份 + "年后认识" + 识字量 + "个字");

for (int 年份 = 0; 年份 < 年限; 年份 = 年份 + 1) {
  if (年份 < 3) {
    continue;
  }
  识字量 = (1 + 每年翻倍数) * 识字量;
}

public class 人 {
}

public class 人 {
  String 姓名 = "无名氏";
  
  public void 自我介绍() {
    System.out.println("我叫" + 姓名);
  }
}

class 世界 {
  public static void main(String[] 参数) {
    人 我 = new 人();
    我.自我介绍();
  }
}

    我.姓名 = "小白";

public class 大人 extends 人 {
  String 责任 = "扶老携幼";
  
  public void 生活() {
    System.out.println("我必须" + 责任);
  }
}

public class 小孩 extends 人 {
  String 想做的事 = "大人的事";
  
  public void 长大() {
    System.out.println("我要做" + 想做的事);
  }
}

class 世界 {
  public static void main(String[] 参数) {
    大人 大白 = new 大人();
    小孩 小白 = new 小孩();
    
    大白.姓名 = "大白";
    大白.自我介绍();
    大白.生活();
    
    小白.姓名 = "小白";
    小白.自我介绍();
    小白.长大();
  }
}

public class 人 {
  String 姓名 = "无名氏";
  int 年龄 = 0;
  float 身高 = 0.0f;
  private String 小秘密 = "";
  
  public void 自我介绍() {
    System.out.println("我叫" + 姓名 + ", 今年" + 年龄 + "岁");
  }
}

class 世界 {
  public static void main(String[] 参数) {
    人 我 = new 人();
    System.out.println(我.小秘密);
  }
}

public String 回答(String 听到的) {
  if (听到的.contains("?")) {
    return "你猜? 答案长度是" + 小秘密.length();
  } else if (听到的.contains("秘密")) {
    小秘密 = 听到的;
    return "我记住了";
  } else {
    return "...";
  }
}

    大人 大白 = new 大人();
    大白.姓名 = "大白";
    大白.年龄 = 30;

  public 大人(String 姓名, int 年龄) {
    this.姓名 = 姓名;
    this.年龄 = 年龄;
  }

大人 大白 = new 大人("大白", 30);

class 排队 {
  public static void main(String[] 参数) {
    人[] 一队 = {
      new 人("小明",14),
      new 人("小红", 5),
      new 人("大黄", 12),
      new 人("阿牛", 9)
    };
    
    for (int 序号 = 0; 序号 < 一队.length; 序号++) {
      一队[序号].自我介绍();
    }
  }
}

    人[] 二队 = new 人[10];
    二队[0] = new 人("阿狗", 11);
    二队[1] = new 人("阿猫", 10);
    // 2空着
    二队[3] = new 人("阿猪", 9);

    for (int 序号 = 0; 序号 < 二队.length; 序号++) {
      if (二队[序号] != null) {
        二队[序号].自我介绍();
      }
    }

    java.util.Arrays.sort(一队, new java.util.Comparator<人>() {
      @Override
      public int compare(人 甲, 人 乙) {
        return 甲.年龄 - 乙.年龄;
      }
    });

人[][] 方阵 = new 方阵[10][15];
方阵[0][0] = new 人("阿狗",3);
方阵[2][4] = new 人("阿猫",4);

    int 数 = 0;
    try {
      数 = Integer.parseInt(参数[0]);
      System.out.println(数 + "的平方根是" + Math.sqrt(数));
    } catch (NumberFormatException e) {
      System.out.println(参数[0] + "看着不像整数");
      return;
    } finally {
      System.out.println("彩蛋");
    }

$ javac 聊天机器人/聊天服务类.java
$ java 聊天机器人/聊天服务类
服务启动在:http://127.0.0.1:5335/service

$ javac 聊天机器人/聊天客户端类.java
$ java 聊天机器人/聊天客户端类 秘密哦
我记住了
$ java 聊天机器人/聊天客户端类 你是谁?
你猜? 答案长度是3

$ java -enableassertions 人测试类