java基础的代码

抽象类

package ChouXiangLei;

abstract class Person {
    abstract void eat();
}

class Chinese extends Person{
    @Override
    void eat() {
        System.out.println("chinese实现的eat");
    }
}

public class Abstract {
    public static void main(String[] args) {
        Person p = new Chinese();
//        Person p = new Person();
        p.eat();
        //使用Chinese类来创建抽象类的对象
    }
}

package ChouXiangLei;
abstract class Person1{
    public Person1() {
        System.out.println("person的构造函数");
    }
    Person1(String name,int age){
        this.name = name;
        this.age = age;
    }
    String name;
    int age;
//    void introduce(){
//        System.out.println("我的名字："+name+",年龄："+age);
//    }
    abstract void introduce();
    abstract void eat();
}
class Chinese1 extends Person1{
    String address;
    Chinese1(){
        super();
        System.out.println("Chinese的构造函数");
    }

    public Chinese1(String name, int age, String address) {
        super(name, age);
        this.address = address;
    }

    @Override
    void eat() {
        System.out.println("吃饭");
    }

    @Override
    void introduce() {
//        super.introduce();
//        System.out.println("我的名字："+name+",年龄："+age);
//        默认是调用父类方法，现在不是抽象方法，改成抽象方法的话就不能用super了，父类方法中也不能写sout
        System.out.println("我的名字："+name+",年龄："+age);
        //现在用的就是子类中实现的抽象方法
        //抽象方法中没有具体的函数方法体，相当于只提供一个接口，**抽象就是没有具体的实体**
        //***Java抽象类可以提供某些方法的部分实现***,但是接口不可以，必须全部实现
        //interface中只能定义方法，而不能有方法的实现，而在抽象类中则可以既有方法的具体实现，又有没有具体实现的抽象方法
    }
}

public class Test {
    public static void main(String[] args) {
        Person1 p = new Chinese1();
        p.eat();
        p.name = "zhagnsan";
        p.age = 18;
        //在这里要有构造的函数进行值传递
        p.introduce();
    }
}

存钱

package cunqian;

public class Account {
    private double balance = 0;
    public void deposit(double money){
        double newBalance = balance + money;
        try {
            Thread.sleep(10);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        balance = newBalance;
    }
    public double getBalance(){
        return balance;
    }
}

//存钱类AddMoneyThread

package cunqian;

public class AddMoneyThread implements Runnable {
    //主类  cunqian.Account
    private Account account;
    private double money;

    public AddMoneyThread(Account account, double money) {
        this.account = account;
        this.money = money;
    }
    @Override
    public void run(){
        account.deposit(money);
    }
}
//测试类Test01

package cunqian;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test01 {
    public static void main(String[] args) {
        Account account = new Account();
        ExecutorService service = Executors.newFixedThreadPool(100);

        for (int i=1; i <= 100; i++){
            service.execute(new AddMoneyThread(account,i));
        }
        service.shutdown();
        while (!service.isTerminated()){}
        System.out.println("账户余额:"+account.getBalance());
    }
}  

扑克

package pocker;

//扑克类
//pokerTest运行类
class Poker{
    private static String[] suites = {"黑桃","红桃","草花","方块"};
    private static int[] faces = {1,2,3,4,5,6,7,8,9,10,11,12,13};

    private Card[] cards;

    /*
        创建扑克牌构造器
    */
    public Poker(){
        cards = new Card[52];
        for(int i=0;i<suites.length;i++){
            for(int j=0;j<faces.length;j++){
                cards[i*13+j] = new Card(suites[i],faces[j]);
            }
        }
    }
    //洗牌
    public void shuffle(){
        for(int i = 0, len = cards.length;i < len; i++){
            int index = (int)(Math.random()*len);
            Card temp = cards[index];
            cards[index] = cards[i];
            cards[i] = temp;
        }
    }
    //发牌
    public Card deal(int index){
        return cards[index];
    }
    public class Card{
        private String suite;
        private int face;
        
        public Card(String suite, int face){
            this.face = face;
            this.suite = suite;
        }
        @Override
        public String toString(){
            String faceStr = "";
            switch(face){
                case 1:faceStr = "A";break;
                case 11:faceStr = "J";break;
                case 12:faceStr = "Q";break;
                case 13:faceStr = "K";break;
                default:faceStr = String.valueOf(face);
            }
            return suite+faceStr;
        }
    }
}

package pocker;

class PokerTest{
    public static void main(String[] args) {
        Poker poker = new Poker();
        poker.shuffle();  //洗牌
        Poker.Card c1 = poker.deal(0);  //发第一张牌
        Poker.Card c2 = poker.new Card("红心", 1);  //自己创建一张牌

        System.out.println(c1);
        System.out.println(c2);
    }
}

抽象类

abstract class
Person {
    abstract void eat();
}
class Chinese extends Person{
    @Override
    void eat() {
        System.out.println("chinese实现的eat");
    }
}
public class Abstract {
    public static void main(String[] args) {
        Person p = new Chinese();
//        Person p = new Person();
        p.eat();
        //使用Chinese类来创建抽象类的对象
    }
}

时间函数

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class DateFormatTest {
    public static void main(String[] args) {
        SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");
        Date date1 = new Date();
        System.out.println(oldFormatter.format(date1));
        DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
        LocalDate date2 = LocalDate.now();
        System.out.println(date2.format(newFormatter));
    }
}

import java.time.Clock;
import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.spi.CalendarDataProvider;

public class DateTimeTest {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.println(cal.get(Calendar.YEAR));
        System.out.println(cal.get(Calendar.MONTH));
        System.out.println(cal.get(Calendar.DATE));
        System.out.println(cal.get(Calendar.HOUR_OF_DAY));
        System.out.println(cal.get(Calendar.MINUTE));
        System.out.println(cal.get(Calendar.SECOND));
        //从上往下是年月日，时分秒

        //java8后的
        LocalDateTime dt = LocalDateTime.now();
        System.out.println(dt.getYear());
        System.out.println(dt.getMonthValue());
        System.out.println(dt.getDayOfMonth());
        System.out.println(dt.getHour());
        System.out.println(dt.getMinute());
        System.out.println(dt.getSecond());
        //年月日，时分秒
        System.out.println("-----------------------------------------------------");

        //获得毫秒数
        Calendar.getInstance().getTimeInMillis();
        System.out.println(System.currentTimeMillis());

        System.out.println(Clock.systemDefaultZone().millis());  //java 8
        System.out.println("-----------------------------------------------------");

        //获得某月的最后一天
        Calendar time = Calendar.getInstance();
        int last = time.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println(last);

    }
}

文件

import java.io.File;

public class fileList {
    //列出目录下的所有文件
    public static void main(String[] args) {
        File f = new File("D:\\360极速浏览器下载");
        /*要保证是一个完整的路径，绝对路径，相对路径和好像不行 */
        System.out.println(f);
        for (File temp:f.listFiles()){
            if (temp.isFile()){
                System.out.println(temp.getName());
            }
        }
    }
}

判断素数

public class sushu {
    public static void main(String[] args) {
        for (int i=1; i < 201; i++){
            boolean b = false;

            for (int j=2; j < i-1; j++){
                int k = i%j;
                if (k==0){
                    b = true;
                }
            }
            if (!b){
                System.out.println(i);
            }
        }
    }
}
/*
* 输出1-200的素数，素数就是除了一跟本身其余的都不能跟他整除*/

数组

public class Array {
    public static void main(String[] args) {
        int arr[][] = {{1,2,3},{2,3,4},{3,4,5}};
        for (int i = 0; i < arr.length; i++){
            for (int j = 0; j < arr[i].length; j++){
                System.out.println(arr[i][j]);
            }
        }
    }
}
//使用数组的.length属性代替数组长度，二维数组也可以用，

冒泡排序

import java.util.Arrays;

public class ArrayMaoPao {
    public static void main(String[] args) {
        int[] ns = {28,12,89,73,65,18,96,50,8,36};
        System.out.println(Arrays.toString(ns));
        for (int i=0; i < ns.length; i++){
            for (int j=0; j < ns.length-i-1; j++){
                if (ns[j] > ns[j+1]){
                    int tmp = ns[j];
                    ns[j] = ns[j+1];
                    ns[j+1] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(ns));
    }
}

泛型

import java.util.ArrayList;

public class FanXing {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();

        arrayList.add("abc");
        arrayList.add("bcd");
        arrayList.add("cde");
        //arraylist对象使用.add方法添加数据

        for (int i = 0; i< arrayList.size(); i++){
            //arraylist的长度对象用size，而不是length，不过两者功能相似
            System.out.println(arrayList.get(i));
//            获取arraylist对象时，使用new出来的选项.get（下标）
//            一般使用一个变量来承接这个arraylist.get()对象。
//            arrayList就是动态数组
            //***泛型，任一类型的数据，ArrayList<String> 就是一个任意类型的泛型，不一定要用String
        }
    }
}

ArrayList就是个泛型类，ArrayList作为集合可以存放各种元素，如Integer, String，自定义的各种类型等，但在我们使用的时候通过具体的
规则来约束，如我们可以约束集合中只存放Integer类型的元素，如 List iniData = new ArrayList<>()

泛型、迭代器

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class collection {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("a");
        set.add("b");
        set.add("c");

        Iterator<String> it = set.iterator();
        int i;
        for(i = 0; i < set.size(); i++){
            boolean b = it.hasNext();
            if (b){
                String s = it.next();
                System.out.println(s);
            }else{
                //因为上面使用的set.size()来确定长度，所以并不会产生b为false的情况
                //i加到3，循环就停止了，所以不会执行if判断，自然也就没有else
                System.out.println(i);
            }
        }
        //使用循环，从第一个开始取，取到最后一个,自动下一个

//        boolean b1 = it.hasNext();
//        if (b1){
//            String s = it.next();
//            System.out.println(s);
//        }
//        boolean b2 = it.hasNext();
//        if (b2){
//            String s = it.next();
//            System.out.println(s);
//        }
//        boolean b3 = it.hasNext();
//        if (b3){
//            String s = it.next();
//            System.out.println(s);
//        }else{
//            System.out.println("没有这个元素了");
//        }
//        迭代器的使用
//        it.hasNext();
//        如果这个游标后面有元素就返回true，否则,false;
//        it.next();
//        返回游标所指位置的下一个元素，取出元素
    }
}

Map和HashMap

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MapTest {
    public static void main(String[] args) {
        HashMap<String,String> hashMap = new HashMap<String,String>();
        Map<String,String> map = hashMap;
// 映射就是一每一个元素包含一个键对象和一个值对象，键不能重复，值可以重复
//        使用put往里存放元素，用get得到数据
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        map.put("4","d");
        int i = map.size();
//        System.out.println(i);
        System.out.println(map.get("2"));
//        取出是根据key的值取出，全部取出有点麻烦，不会
    }
}

99乘法表

public class ChengFaBiao {
    public static void main(String[] args) {
        for (int i = 1;i <= 9; i++){
            for (int j=1;j <= i; j++){
                System.out.print(j+"*"+i+"="+(i*j));
                System.out.print("\t");
            }
            System.out.println();
        }
    }
}

猴子吃桃 （循环逆使用）

public class Monkey_peach {
    public static void main(String[] args) {
        int[] peach = new int[10];
        peach[9] = 1;
        for (int i = peach.length-1;i > 0; i--){
            peach[i-1] = 2*(peach[i] + 1);
        }
        //从后往前推
        int sum = 0;
        for (int i = 0;i < peach.length;i++){
//            System.out.println(peach[i]);
            sum += i;
        }
        System.out.println("桃子数："+sum);
    }
}
/**
 * 猴子吃桃问题，第一天吃掉一半，第二天吃掉剩下的一半多一个，以后类推，到第十天只剩一个桃，一共有几个
 */

水仙花

public class ShuiXianHua {
    public static void main(String[] args) {
        for (int i=100;i < 1000;i++){
            int n1,n2,n3;
            int k = i;
            n1 = k / 100;
            k %= 100;
            n2 = k / 10;
            k %= 10;
            n3 = k;
            //分别求出个十百位来，用于下面的相乘和比较
            if (i == (getCube(n1)+getCube(n2)+getCube(n3))){
                System.out.println(i);
            }
        }
    }

   public static int getCube(int n){
        return n*n*n;
   }
}
/**
 * 水仙花数是一个三位数，就是各个数字的立方和等于这个数字本身
 */

最大公约数和最小公倍数

import java.util.Scanner;

public class CommonDivisor {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int a = in.nextInt();
        System.out.println("请输入二个数：");
        int b = in.nextInt();
        System.out.println(a+b+"最大公约数是："+getMaxCommon_Divisor(a,b));
        System.out.println(a+b+"最小公倍数是："+getMincommon_multiple(a,b));
    }

    private static int getMincommon_multiple(int a, int b) {
        return (a*b) / getMaxCommon_Divisor(a,b);
    }

    private static int getMaxCommon_Divisor(int a, int b) {
        int max = Math.max(a,b);
        int min = Math.min(a,b);
        int mod = max % min;
        if (mod == 0){
            return min;
        }else {
            return getMaxCommon_Divisor(mod,min);
        }
    }
}

/**
 * 输入两个正整数，求最大公约数和最小公倍数
 */

线程

public class Main {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start(); // 启动新线程
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("start new thread!");
    }
}
//从Thread派生出一个新的类，并重新run方法，就可以实现线程的具体操作

线程执行具体代码方法二

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); // 启动新线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("start new thread!");
    }
}

将数组排序后存放到新数组

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        int arr[] = {77,98,768,908,354,789,576};
        int b[] = new int[6];
        //创建一个新数组对象
        Arrays.sort(arr);
        for (int i = 0; i < arr.length - 1; i++){
            b[i] = arr[i];
        }
        System.out.println(Arrays.toString(b));

    }
}

StringBuffer和StringBuilder 的使用

import java.util.StringJoiner;

public class StringBuffer {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(1024);

        for (int i = 0; i < 1000; i++){
            sb.append(i);
            sb.append(",");
        }
        String s = sb.toString();
//        System.out.println(s);
        var sb1 = sb;
        System.out.println(sb1);

        var sb2 = new StringBuilder(1024);
        sb2.append("Mr").append("Bob!").insert(0,"hello,");
        //在StringBUilder上进行链式拼接,insert 在0的位置插入这个字符串
//        System.out.println(sb2);
        System.out.println("sb2.toString() = " + sb2.toString());
//        StringBuffer是早期StringBuilder的线程安全版本，两者作用"相同。

        String[] names = {"Bob", "Alice", "Grace"};
        var sj = new StringJoiner(",");
        //StringJoiner是java提供的专门用来拼接字符串的类，在字符串中添加括号里的内容，调用add方法进行添加
        for (String name : names){
            sj.add(name);
        }
//        System.out.println(sj.toString());
        var sj1 = String.join(",", names);
        System.out.println(sj1);
        //静态的jion方法，和Stringjioner方法类似
    }
}

Math类

import java.util.ArrayList;
import java.util.Random;

public class MathTest {
    public static void main(String[] args) {
//        System.out.println(Math.abs(-100));//求绝对值  100
//        System.out.println(Math.max(88, 999));//求最大值，只能在两个中比较 999
//        System.out.println(Math.min(88, 999));//求最小值，只能在两个中比较 88
//        System.out.println(Math.pow(2,10));//计算平方，2的10平方 1024.0
//        System.out.println(Math.sqrt(16));  //开平方  4.0
//        System.out.println(Math.random()); //在0-1之间生成一个随机数
//        System.out.println(Math.random()*10);

        Random r = new Random();
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add(String.valueOf(r.nextInt())); //将r.nextInt（） 转换为String的值
        arrayList.add(String.valueOf(r.nextInt(10)));
        arrayList.add(String.valueOf(r.nextFloat()));
        r.nextFloat();
        r.nextDouble();
        for (int i = 0; i < arrayList.size(); i++){
            System.out.println(arrayList.get(i));
        }
    }
}