JAVA

java -version

/usr/libexec/java_home -V

echo $JAVA_HOME

echo $PATH

sudo rm -rf /Library/Java/JavaVirtualMachines/jdk1.8.0_XXX.jdk

sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 
sudo rm -rf /Library/Application\ Support/Oracle/Java

//abc

/*abc*/

/** * 这是一个文档注释示例
 * 它通常包含有关类、方法或字段的详细信息
 */
public class MyClass {
       // 类的成员和方法
}

javadoc -d 目的文件夹名 -javadoc标签1  - Javadoc标签2  ……  源文件名.java

/**
 * 我是主说明
 *
 * @author buer
 * @version 1.0
 */
public class hello {
    /**
     * 默认构造器，虽然在这个只包含静态方法的类中不会被使用，但为了消除警告而显式定义。
     */
    public hello() {
        // 这里没有特殊的初始化代码，因为类只包含静态方法
    }

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数数组
     */
    public static void main(String[] args) {
        System.out.println("hello,java");
    }
}

\t   对齐
\n   换行
\\   \
\"   "
\'   '
\r   回车

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

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;    // 声明并初始化 z
String s = "runoob"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

public void Fun() {
    int localVar = 10; // 局部变量
    // ...
}

public class Fun {
    int instanceVar; // 实例变量
}

public class Fun {
    static int classVar; // 类变量
}

public void Fun(int a ）{
        //在fangFa方法中，a就是参数变量
}

public class Fun {
    // 成员变量
    private int instanceVar;
    // 静态变量
    private static int staticVar;

    public void method(int paramVar) {
        // 局部变量
        int localVar = 10;

        // 使用变量
        instanceVar = localVar;
        staticVar = paramVar;

        System.out.println("成员变量: " + instanceVar);
        System.out.println("静态变量: " + staticVar);
        System.out.println("参数变量: " + paramVar);
        System.out.println("局部变量: " + localVar);
    }

    public static void main(String[] args) {
        Fun v = new Fun();
        v.method(20);
    }
}

variable x = (expression) ? value if true : value if false

( Object reference variable ) instanceof (class/interface type)

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

while( 布尔表达式 ) {
  //循环内容
}

do {
       //代码语句
}while(布尔表达式);

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

for(声明语句 : 表达式)
{
   //代码句子
}

import java.util.Arrays;

public class MyCommons {
    public static void main(String[] args) {
        //静态初始化
        //int[] arr;
        //arr=new int[]{1,2,3,4};
        int[] arr=new int[]{1,2,3,4};//简写
        //动态初始化
        int[] arr2=new int[4]
        
        //System.out.printf(arr);直接输出会隐式调用tostring方法，输出乱码（类型简写和数值哈希值）
        System.out.println(Arrays.toString(arr));
    }
}

int[][] arr=new int[][]{{1,2,3},{4,5,6},{7,8,9},{10,11,12}}
arr[0][1]//第一项的第二个，2

import java.util.ArrayList; // 导入ArrayList类

ArrayList<String> myList = new ArrayList<String>();//字符型数组
ArrayList<Integer> myList = new ArrayList<Integer>();//整型数组
ArrayList<Integer> myList = new ArrayList<>();
//在Java 7及以上版本中，可以使用菱形操作符（<>）来代替显式类型实参

myList.add(1); // 向ArrayList中添加元素

public class MyCommons {
    public static void main(String[] args) {
        int[] arr=new int[]{1,2,9,4,0,7,6,4,6,8};
        int num=0;//最小值arr[0]
        for(int i=0;i<arr.length;i++){
            //最大值
            //if(arr[i]>num){
            //  num=arr[i];
            //}
            //最小值
            //if(arr[i]<=num){
            // num=arr[i];
            //}
            num+=arr[i];//和
            //反转：i<arr.length/2   arr[i]<->arr[arr.length-1-i]
        }
        System.out.println(num);
        //System.out.println((double)num/arr.length);平均值
    }
}

add()：将指定的元素添加到此列表的末尾。
ArrayList<String> list = new ArrayList<>();  
list.add("Apple");  
list.add("Banana");

add(int index, E element)：在列表的指定位置插入指定的元素。
ArrayList<String> list = new ArrayList<>();  
list.add("Apple");  
list.add("Banana");  
list.add(1, "Orange"); // 插入后列表为 ["Apple", "Orange", "Banana"]

remove(int index)：删除列表中指定位置的元素。
ArrayList<String> list = new ArrayList<>();  
list.add("Apple");  
list.add("Banana");  
list.remove(0); // 删除后列表为 ["Banana"]

get(int index)：返回列表中指定位置的元素。
ArrayList<String> list = new ArrayList<>();  
list.add("Apple");  
list.add("Banana");  
String fruit = list.get(0); // fruit 将被赋值为 "Apple"

size()：返回列表中的元素个数。
ArrayList<String> list = new ArrayList<>();  
list.add("Apple");  
list.add("Banana");  
int size = list.size(); // size 将被赋值为 2

contains(Object o)：判断列表中是否包含指定的元素。
ArrayList<String> list = new ArrayList<>();  
list.add("Apple");  
list.add("Banana");  
boolean hasApple = list.contains("Apple"); // hasApple 将被赋值为 true

Collections.sort 数组排序
import java.util.ArrayList;  
import java.util.Collections;  
  
public class Main {  
    public static void main(String[] args) {  
        ArrayList<Integer> numbers = new ArrayList<>();  
        numbers.add(3);  
        numbers.add(1);  
        numbers.add(2);  
          
        Collections.sort(numbers);  
          
        for (int num : numbers) {  
            System.out.print(num + " ");  
        } // 输出：1 2 3  
    }  
}

import java.util.ArrayList;//引入类

public class ZhiShu {
    public static void main(String[] args) {
       ArrayList<Integer> myList = new ArrayList<>();//声明动态整数数组
        for(int a=2;a<=100;a++){//遍历2-100
            boolean n=true;//标识
            for(int b=2;b<a;b++){//遍历并比较2-a之间
                if(a%b==0){
                    n=fasle;//不是质数就更改标识
                    break;
                }
            }
            if(n){
                myList.add(a);//给数组添加元素
            }
        }
        System.out.println(myList);//输出
    }
}

import java.util.Scanner;

public class JiZhang {
    private double balance;
    public void addFun(double num){//收入方法
        balance+=num;
        System.out.printf("收入"+num+"元，当前余额："+balance);
    }
    public void subFun(double num){//支出方法
        balance=balance-num;
        System.out.printf("支出"+num+"元，当前余额："+balance);
    }
    public void cxFun(){//查询方法
        System.out.printf("当前余额："+balance);
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        JiZhang jiZhangInstance = new JiZhang(); // 创建JiZhang类的实例
        boolean sta=true;
        while (sta){
            System.out.print("记账系统\n1.查询余额\n2.收入\n3.支出\n4.退出");
            String sce=scanner.nextLine();
            switch (sce){
                case "1":
                    jiZhangInstance.cxFun();
                    break;
                case "2":
                    System.out.print("请输入收入金额：");
                    double income = scanner.nextDouble();
                    jiZhangInstance.addFun(income);
                    break;
                case "3":
                    System.out.print("请输入支出金额：");
                    double expense = scanner.nextDouble();
                    jiZhangInstance.subFun(expense);
                    break;
                case "4":
                    sta=false;
                    break;
                default: // 如果用户输入了无效的选择
                    System.out.println("无效的选择，请重新输入。");
            }
            scanner.nextLine(); // 消耗掉输入后的换行符
        }
    }
}

public class Phone {//创建类
    String color = "红色";//设计类的属性
    public void Messages(String txt) {
    //设计类的方法，void指不需要方法返回，如果需要返回值，将void替换为返回值的数据类型，结尾return
    //方法必须在类里，不能独立存在
        System.out.printf("手机发出了一条短息，内容是：" + txt);
    }
}

public class PhoneText {
    public static void main(String[] args) {
        Phone iphone = new Phone();//初始化，创建类的对象（实例化）
        System.out.printf("外观："+iphone.color);//通过创建的对象，调用其内部声明的属性和方法
        iphone.Messages("你好，对象");    }
}

权限修饰符 类名(形参列表){}

public static void main(String[] args) {  
        // 使用无参构造器创建对象  
        Person person1 = new Person();  
        System.out.println(person1); // 输出: Person{name='Unknown', age=0}  
  
        // 使用带参构造器创建对象  
        Person person2 = new Person("Alice", 25);  
        System.out.println(person2); // 输出: Person{name='Alice', age=25}  
    } 

//构造代码块：
{
    System.out.print("我是代码块");
}

//特点：优先于构造方法执行，每new一次就执行一次

//静态代码块
static{
  System.out.print("我是静态代码块");
}
//特点：优先于构造代码块和构造方法执行，只执行一次

public class A{
  int a;//外部成员变量
  static class B{
  int b;//内部成员变量
    void Bfun(){
      this.b;//调用内部变量
      A.this.a;//调用外部变量
  }
}

public class A{
  static class B{
    
  }
}

A.B name=new A.B()

public class A{
  class B{
    
  }
}

A.B name=new A().new B()

public class A{
  void run(){
    class B{//局部内部类
      void eat(){}
    }
    new B().eat()//间接调用
  }
}

class Text{
  A name=new A();
  name.run();//调用
}

interface Greeting {  
    void sayHello();  
}  
  
public class Main {  
    public static void main(String[] args) {  
        //这里，创建了一个Greeting接口的匿名内部类实例，并覆盖了sayHello方法 
        Greeting greeting = new Greeting() {
            @Override  
            public void sayHello() {  
                System.out.println("Hello, World!");  
            }  
        };  
          
        // 调用匿名内部类实现的方法  
        greeting.sayHello();  
    }  
}

public enum Day{//使用enum关键字定义枚举类
  SUNDAY,  
  MONDAY,  
  TUESDAY,  
  WEDNESDAY,  
  THURSDAY,  
  FRIDAY,  
  SATURDAY
}

public class Main {  //使用
    public static void main(String[] args) {  
        Day today = Day.MONDAY;  
        switch (today) {  
            case MONDAY:  
                System.out.println("Today is Monday.");  
                break;  
            case TUESDAY:  
                System.out.println("Today is Tuesday.");  
                break;  
            // 其他情况的处理...  
            default:  
                System.out.println("Today is some other day.");  
        }  
          
        for (Day day : Day.values()) {  
            System.out.println(day);  
        }  
    }  
}
//在这个例子中，我们创建了一个Day类型的变量today，并将其设置为MONDAY。然后，我们使用switch语句根据today的值执行不同的操作。最后，我们使用for-each循环遍历Day枚举类的所有实例，并打印它们。

class 父类 {
}
 
class 子类 extends 父类 {
}

class 父类 {
}
 
class 子类 extends 父类 {
}

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

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}

声明类：
final class 类名 {//类体}

声明方法：
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}

  //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   

public class duoTai {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型：Animal引用指向Dog对象
        animal.makeSound(); // 输出 "777"

        //animal1.eat();无法直接运行
        Dog dog=(Dog)animal;//向下转型，将animal转换为Dog类型
        dog.eat();//888
    }
}
class Animal {
    public void makeSound() {
        System.out.println("666");
    }
}

class Dog extends Animal {
    public void makeSound() {  //重写了makeSound方法
        System.out.println("777");
    }
    void eat(){
        System.out.println("888");
    }
}

public class chouXiang extends Animal02{
    public void run(){//必须调用，不然会报错
        
    }
    public static void main(String[] args) {
        
    }
}
abstract class Animal02{
    int age;
    public abstract void run();
    public void eat(){
        System.out.print("eat");
    }
}

[权限修饰符] interface 接口名称 [extends 父类接口1，父类接口2] {
        // 定义常量
        // 抽象方法
}


interface Aanimal{//定义 动物 接口，抽象方法 跑 和 吃
    void run();
    void eat();
}

interface Cute{//定义 可爱 接口，抽象方法 看起来喜欢
    void looklike();
}

class Cat implements Aanimal,Cute{//猫类 实现 动物 和 可爱 接口，必须有 跑 和 吃 和 看起来喜欢方法
    public void run(){
        System.out.print("跑");
    }
    public void eat(){
        System.out.print("吃");
    }
    public void looklike(){
        System.out.print("看起来喜欢");
    }
}

java.lang.Objact

class BankTest{
  public static void main(String[] args){
    Bank name1=Bank.getfun();
  }
}

//饿汉式
class Bank{
  private Bank(){}//类构造器私有化
  private static Bank name=new Bank();//在类内部创建实例，也必须是static
  public static Bank getfun(){//使用方法获取实例，必须是static
   return name;
  }
}
//懒汉式
class Bank{
  private static Bank name=null;
  public static Bank getfun(){
    if(name==null){
      name=new Bank();
    }
    return name;
  }
}

try{
  •••••//可能产生异常的代码
}catch（异常类型1 e){
  //当产生异常类型1型异常时的处置措施
  System.out.println("异常1原因: " + e.getMessage());
}catch（异常类型2 e){
  //当产生异常类型2型异常时的处置措施
  System.out.println("异常2详细信息: " + e.printStackTrace());
}finally{
  //无论是否发生异常，都无条件一定执行的语句
  //和直接在try-catch-finally结构下面直接写的不同，直接写的语句在有报错的情况下不会执行
  System.out.println("清理资源...");  
｝

public void Fun() throws 异常类型1, 异常类型2 {  
    //可能抛出异常的代码  
}

class Parent {  
    public void doSomething() throws IOException {  
        // ... 可能抛出IOException的代码 ...  
    }  
}  
  
class Child extends Parent {  
    @Override  
    public void doSomething() throws FileNotFoundException { 
        // FileNotFoundException是IOException的子类  
        // ... 可能抛出FileNotFoundException的代码 ...  
    }  
}

public class CustomException extends Exception {  
    public CustomException(String message) {  
        super(message);  
    }  
}  
  
// 使用自定义异常  
try {  
    throw new CustomException("自定义异常发生");  
} catch (CustomException e) {  
    System.out.println("捕获到自定义异常: " + e.getMessage());  
}

public class MyThread extends Thread {  
    @Override  
    public void run() {  
        // 线程执行的代码  
        System.out.println("MyThread is running");  
    }  
  
    public static void main(String[] args) {  
        MyThread thread = new MyThread();  
        thread.start();  // 启动线程  
    }  
}

public class MyRunnable implements Runnable {  
    @Override  
    public void run() {  
        // 线程执行的代码  
        System.out.println("MyRunnable is running");  
    }  
  
    public static void main(String[] args) {  
        Thread thread = new Thread(new MyRunnable());  
        thread.start();  // 启动线程  
    }  
}

//1-同步代码块
synchronized(锁对象){
  //线程可能出现不安全的代码
}
//锁对象：代表锁的一个对象，一般用this，指代当前对象实例，也就是调用这些方法的对象

//2-同步方法
修饰符 synchronized 返回值类型 方法名(){
  方法体
  return 结果
}

public class delLockText{
    final Object lock1=new Object();
    final Object lock2=new Object();

    public static void main(String[] args) {
        delLockText delLockText=new delLockText();

        Thread thread1=new Thread(delLockText.new Thread1());
        Thread thread2=new Thread(delLockText.new Thread2());

        thread1.start();
        thread2.start();
    }

    class Thread1 extends Thread{
        @Override
        public void run() {
            synchronized (lock1){
                System.out.println("Thread1获取lock1");
                synchronized (lock2){
                    System.out.println("Thread1获取lock2");
                }
            }
        }
    }
    class Thread2 extends Thread{
        @Override
        public void run() {
            synchronized (lock2){
                System.out.println("Thread2获取lock2");
                synchronized (lock1){
                    System.out.println("Thread2获取lock1");
                }
            }
        }
    }
}

import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock; 

Lock lock = new ReentrantLock(); 

public void increment() {  
        lock.lock();  
        try {  
            count++;  
        } finally {  
            lock.unlock();  
        }  
    }  

public class MyCS implements Callable<String>{
    @Override
    public String call() throws Exception {
        return “涛哥和金莲...的故事”；
    ｝
｝
public class Test {
    public static void main(Stringl] args){
          MyCS my_cs = new MyCS();
          //FutureTask (Callable<V> callable)
          FutureTask<String> futureTask = new FutureTask<>(my_cs);
          //创建Thread对象->Thread（Runnabletarget）
          Thread t1 = new Thread (futureTask);
          t1. start;
          //调用get方法获取ca11方法返回值
          System.out.println(futureTask.get);
    }
}

public volatile int sharedVariable = 0;

public class Text01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor_service= Executors.newFixedThreadPool(2);
        //MyRunnable
        executor_service.submit(new MyRunnable());
        //MyCallable
        Future future=executor_service.submit(new MyCallable());
        System.out.println(future.get());
        //关闭线程池
        executor_service.shutdown();
    }
}
//MyRunnable
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程，执行了");
    }
}
//Callable
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "执行";
    }
}

public class DemoOlTimer {
  public static void main (String[] args) {
    Timer timer = new Timer ();
    timer.schedule (new TimerTask {
      @Override
      public void run () {
        system.out.println（"起床了~~~"）；
      }
    },new Date(),2000L);
  }
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class iteratorCS {
    public static void main(String[] args) {
        //Collection<String> arr=new ArrayList<>();
        ArrayList<String> arr=new ArrayList<>();
        
        arr.add("001");
        arr.add("002");
        arr.add("003");
        arr.add("004");

        Iterator<String> iterator= arr.iterator();

        while (iterator.hasNext()){//检查集合中是否还有更多的元素           
             String t=iterator.next();//返回集合中的下一个元素
            //System.out.println(t);
            if("003".equals(t)){//匹配003并删除
                arr.remove("003");//从集合中删除上一次通过next()方法返回的元素
                System.out.println(arr);
            }
        }
        for(String i:arr){//for-each遍历
            //System.out.println(i);
        }
    }
}