我的Java学习笔记

break以及continue

package com.iteasyup.javase;

public class break关键字 {

    //循环1-10然而当我循环到5的时候循环完结
    //循环1-10然而循环到5的时候跳过5输入
    
    public static void main(String[] args) {
        
        
//        for (int i = 1; i <= 10; i++) {
//            System.out.println(i);
//            if (i == 5) {
//                //break:完结以后循环
//                break;
//            }
//        }
        
        for (int i = 1; i < 11; i++) {
            if (i == 5) {
                //continue:跳过本次循环，进入下一次循环
                continue;
            }
            System.out.println(i);
        }
        
        
    }
}

collection的应用

package com.iteasyup.javase;

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

public class CollectionTest {

    public static void main(String[] args) {
        
        //创立Collection汇合对象
        //泛型：汇合存储的数据的数据类型，jdk1.5当前才呈现的
        //只能写援用类型
        Collection<Integer> coll = new ArrayList<>();
        
        //增加数据信息
        coll.add(10);
        coll.add(20);
        coll.add(30);
        coll.add(30);
        
        //删除数据
        coll.remove(20);
        
        //批改数据：
        coll.remove(10);
        coll.add(40);
        
        //求汇合元素个数的办法，即长度
        int size = coll.size();
        System.out.println(size);
        
        //断定汇合中是否蕴含某元素
        System.out.println(coll.contains(50));
        
        //断定汇合是否为空
        System.out.println(coll.isEmpty());
        
        //输入汇合中的数据
        for (Integer a : coll) {
            System.out.println(a);
        }
        //间接打印对象名，也能够输入
        System.out.println(coll);
        
        //迭代器的形式输入
        Iterator<Integer> iterator = coll.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

do while循环以及while循环的区别

package com.iteasyup.javase;

public class 循环之dowhile {

    public static void main(String[] args) {
        
        //循环输入1-10
//        int i = 1;
//        do {
//            System.out.println(i);
//            i++;
//        } while (i < 11);
        
        //输入1+2+3+4+5=?
        
//        int s = 0;
//        int i = 1;
//        do {
//            s = s + i;
//            i++;
//        } while (i < 6);
//        System.out.println(s);
        
        
        //鸡兔同笼，一共35个头，94只脚，鸡多少只，兔多少只
        
        int i = 1;
        do {
            if (i * 2 + (35-i) * 4 == 94) {
                System.out.println("鸡有：" + i + "只；" + "兔有：" + (35 - i) + "只");
            }
            i++;
        } while (i < 36);
        
        //while循环和do while循环之间的区别
        //①while循环先判断后执行，不肯定有后果
        //②do while循环先执行后判断，肯定至多会有一个后果
    }
    
}

foreach循环

package com.iteasyup.javase;

public class foreac循环 {

    public static void main(String[] args) {
        
        //定义一个数组
        int[] a = {11,22,33,44,55};
        
        //foreach循环遍历数据
        //int示意循环数组的数据类型  i用于示意数组中的所有元素的变量名（能够自定义）
        //a示意要循环数组的变量名
        for (int i : a) {
            System.out.println(i);
        }
        
        String[] b = {"da","ji","ge","you","are","beautiful"};
        
        for (String bb : b) {
            System.out.println(bb);
        }
    }
}

for死循环

package com.iteasyup.javase;

import java.util.Scanner;

public class for死循环 {

    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        
//        for (int i = 1; i < 2; i--) {
//            System.out.println(i);
//        }
        
//        for (; ; ) {
//            System.out.println("大吉哥好帅");
//        }
        
        for (; ; ) {
            System.out.println("请抉择：1.VIP会员 2.一般会员 3.删除会员信息 4.增加会员信息 5.退出");
            int choose = in.nextInt();
            if (choose == 1) {
                System.out.println("VIP会员");
            }
            if (choose == 2) {
                System.out.println("一般会员");
            }
            if (choose == 3) {
                System.out.println("删除会员信息");
            }
            if (choose == 4) {
                System.out.println("增加会员信息");
            }
            if (choose == 5) {
                System.out.println("退出零碎");
                break;
            }
        }
    }
    }

lambda运算符的应用

package com.iteasyup.javase;

public class T01 {

    //java8新个性：lambda
    //构造
    //（参数） -> {执行体}
    //函数式编程（接口）（一个接口只有一个形象办法）
    
    public int f1(Math math, int a, int b) {
        return math.js(a, b);
    }
    
    public static void main(String[] args) {
        
        T01 t01 = new T01();
//        Math math = () -> 执行体
        Math math = (a, b) -> a + b;
        int f1 = t01.f1(math, 3, 5);
        
        System.out.println(f1);
        
    }

}


package com.iteasyup.javase;

public interface Compare {

    String compareTo(String s1, String s2);
}

package com.iteasyup.javase;

public class TestCompare {

    public void f1(Compare compare, String s1, String s2) {
        System.out.println(compare.compareTo(s1, s2));
    }
    
    public static void main(String[] args) {
        Compare compare = (s1, s2) -> {
            if (s1.length() - s2.length() > 0) {
                return s1;
            }
            else {
                return s2;
            }
        };
        new TestCompare().f1(compare, "liuji", "dajige");
    }
}

List的应用

package com.iteasyup.javase;

import java.util.ArrayList;
import java.util.List;

public class TestList {

    public static void main(String[] args) {
        //创立List汇合
        List<String> list = new ArrayList<>();
        
        //增加数据
        list.add("叶秋");
        list.add("叶修");
        list.add("陈果");
        list.add("叶秋");
        
        //删除list汇合中某条元素,能够写索引，也能够写值
        list.remove(2);
        
        //批改list汇合中的某个元素
        list.set(1, "a");
        
        //获取list汇合中的某个元素
        System.out.println(list.get(0));

        //for循环输入整个List汇合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //间接输入list中所有元素
        System.out.println(list);
    }
}

main以及syso输入

package com.iteasyup.javase;

public class Test1 {

    //java代码
    // main办法 作用：java代码的运行主程序 想要运行java
    //代码时，必须提供 快捷键 main+enter键
    public static void main(String[] args) {
        //syso java输入语句
        //快捷键 syso+enter
        System.out.println(10);
        System.out.println("hello world");
        System.out.println();
    }
}

map的应用

package com.iteasyup.javase;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class TestMap {

    public static void main(String[] args) {
        //创立一个map汇合
        //有HashMap，Hashtable
        //HashMap和Hashtable之间的区别：
        //①HashMap中能够将null当成键或者值，Hashtable不能够
        //②HashMap线程不平安，速度快；Hashtab线程平安，速度慢
        
        Map<Integer, String> map = new HashMap<>();
        
        //增加数据
        //null既能够当key，也能够当value，然而只有在 new HashMap的时候能够
        map.put(1, "小王");
        map.put(2, "小黑");
        map.put(3, "小白");
        map.put(null, null);
        
        //删除
        map.remove(2);
        map.remove(3, "小黑");
        
        //批改，map中如果key反复，会获取最初一个值
        map.put(1, "效率");
        
        //取值：通过键
        System.out.println(map.get(1));
        
        //想要获取所有的键，返回一个Set汇合
        Set<Integer> keys = map.keySet();
        
        for (Integer integer : keys) {
            System.out.println(map.get(integer));
        }
        
        //间接获取所有的值，返回一个Collection汇合
        Collection<String> values = map.values();
        for (String string : values) {
            System.out.println(string);
        }
        
        //间接输入map
        System.out.println(map);
    }
}

Reader、Writer+Buff

package com.iteasyup.javase;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class Test9 {

    public static void main(String[] args) throws IOException {
        
        File file = new File("D:\\xiaoli.txt");
        File file2 = new File("D:\\test6.txt");
        
        Reader reader = new FileReader(file);
        Writer writer = new FileWriter(file2);
        
        BufferedReader b = new BufferedReader(reader);
        BufferedWriter w =  new BufferedWriter(writer);
        
        String s = "";
        while ((s = b.readLine()) != null) {
            System.out.println(s);
            s = s.replace("小", "大");
            System.out.println(s);
            w.write(s + "\r\n");
        }
        
        w.close();
        b.close();
        writer.close();
        reader.close();
    }
}

Reader+Buff

package com.iteasyup.javase;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class TestBufferedReader {

    public static void main(String[] args) throws IOException {
        
        File file = new File("D:\\aa.txt");
        
        Reader reader = new FileReader(file);
        
        //创立缓冲流
        BufferedReader br = new BufferedReader(reader);
        
        String s1 = "";
        
        while ((s1 = br.readLine()) != null) {
            System.out.println(s1);
        }
        
        br.close();
        reader.close();
    }
}

Reader的应用

package com.iteasyup.javase;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class TestReader {

    public static void main(String[] args) {
        
        //1.创立file对象
        File file = new File("D:\\aa.txt");
        
        //2.创立字符输出流
        Reader reader = null;
        try {
            reader = new FileReader(file);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        //3.读数据
        int result = 0;
        try {
            if (reader != null) {
                while((result = reader.read()) != -1) {
                    System.out.println((char)result);
                }
            }
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

Set的应用及其与List之间的区别

package com.iteasyup.javase;

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

public class TestSet {

    public static void main(String[] args) {
        
        //List汇合和Set汇合之间的区别？
        //Set汇合无序、值不可反复、无索引
        //List汇合有序、值可反复、有索引
        //Collection汇合无序，值可反复
        
        //Set汇合如何去除反复数据
        //①Set能够主动去除String类的反复数据
        //②Set不能主动去除通过创建对象的反复变量，
        //须要重写hashcode（比拟以后对象是否一样），和equals办法（比拟堆空间的值），即source下点击
        
        
        //创立set汇合
        Set<String> set = new HashSet<>();
        
        //增加数据
        set.add("aa");
        set.add("bb");
        set.add("cc");
        set.add("dd");
        
        //删除元素
//        set.remove("cc");
//        
//        //更新
//        set.remove("dd");
//        set.add("xx");
        
        
        //获取set外面的元素
        //①foreach
        for (String string : set) {
            System.out.println(string);
        }
        
        //②间接输入汇合名
        System.out.println(set);
    }
}

Set上面的update和delete办法

package com.jihezonghlianxi.javase;

public class StudentCheckSet implements StudentCheck{

    @Override
    public void addStudent(Student student) {
        Modle.SET.add(student);
    }

    @Override
    public void deleteStudent(int id) {
        Student s1 = null;
        for (Student student : Modle.SET) {
            if (student.getId() == id) {
                s1 = student;
            }
        }
        //foreach循环底层是迭代器，如果删除就会变为null，下一层就无奈循环，会呈现谬误
        Modle.SET.remove(s1);
    }

    @Override
    public void updateStudent(int id, Student student) {
        //这几个办法都没被static润饰，并且在同一个类下，能够间接调用
        deleteStudent(id);
        addStudent(student);
    }
}

switch语句

package com.iteasyup.javase;

import java.util.Scanner;

public class Testswitch语句 {

    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        // 需要：输出1个数字来示意周几，如果输出1，打印周一吃方便面
        //如果输出2，打印周二吃面条
        //如果输出3，打印周三吃麻辣烫
        //如果输出4，打印周四吃米饭
        //如果输出5，打印周五吃饺子
        //如果输出6，打印周六吃包子
        //如果输出7，打印周日喝白开水
        //否则，输入输出谬误，只能输出1-7的数字
        
        System.out.println("请输出一个数字：");
        int num = in.nextInt();
        
        switch (num) {
        case 1:
        case 3:
        case 5:
            System.out.println("周一三五吃方便面");
            break;
        case 2:
        case 4:
        case 6:
            System.out.println("周二四六喝白开水");
            break;
        case 7:
            System.out.println("周日吃米饭");
            break;
            

        default:
            System.out.println("输出谬误，只能输出1-7的数字");
            break;
        }
    }
}

while循环

package com.iteasyup.javase;

public class 循环之while {

    public static void main(String[] args) {
        
        //输入1-10所有的数字
//        int i = 1;
//        while (i < 11) {
//            System.out.println(i);
//            i++;
//        }
        
        //输入2 4 6 8 10
//        int i = 2;
//        while (i < 11) {
//            System.out.println(i);
//            i += 2;
//        }
        

        //输入1 2 4 7 11 16
//        int i = 1;
//        int s = 1;
//        while (i <= 6) {
//            System.out.println(s);
//            s = s + i;
//            i++;
//        }
        
//        int i = 1;
//        int s = 0;
//        while (i <= 5) {
//            s = s + i;
//            System.out.println(s);
//            i++;
//        }
        
        int sum = 1;
        int i = 0;
        while (i < 6) {
            sum = sum + i;
            System.out.println(sum);
            i++;
        }
    }
}

Writer的应用

package com.iteasyup.javase;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class TestWriter {

    public static void main(String[] args) {
        
        //1.创立file类对象
        File file = new File("D:\\aa.txt");
        
        //2.创立字符输入流
        Writer writer = null;
        try {
             writer = new FileWriter(file);
             //3.输入数据
             String s1 = "小明说小利真丑";
             writer.write(s1);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            //4.关流
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

返回值

package com.iteasyup.javase;

public class ReturnType {

    //花钱买10元的水，将残余的钱失去
    public static void main(String[] args) {
        int buywater = ReturnType.buywater(100);
        System.out.println(buywater);
    }
    
    
    public static int buywater(int money) {
        money = money - 10;
        return money;
    }
}

办法重载不便输出

package com.iteasyup.javase;

public class Test {

    //办法重载：将办法名雷同，参数列表不同的办法称之为重载
    //重载产生在同一个类下，并且重载办法和返回值无关
    //***构造方法能够重载
    //Java中，最大的重载办法是syso
    //求最大值max
    
    public int max(int a, int b) {
         return a > b ? a : b;
    }
    
    public double max(double a, double b) {
        return a > b ? a : b;
    }
}


package com.iteasyup.javase;

public class T01 {

    public static void main(String[] args) {
        
        //求两个整数的最大值
        Test test =  new Test();
        int max = test.max(10, 29);
        System.out.println(max);
        
        double max2 = test.max(2.3, 5.6);
        System.out.println(max2);
    }
}

获取以后零碎工夫 日期 Date

package com.iteasyup.dao;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDate {

    public static void main(String[] args) {
        Date date = new Date();
        SimpleDateFormat now = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = now.format(date);
        System.out.println(time);
    }
}

继承关系的高低转型

package com.iteasyup.com;

public class MasterTest {

    public static void main(String[] args) {
        
        //创立Master对象
        Master master = new Master();
        //创立参数对象
        Animal animal = new Cat();//对象的上转型，只能调用父类和子类共有的办法
//        master.feed(animal);
        
        animal.eat();
        
        //对象的下转型
        //用来调用子类独有的办法
        Cat cat = (Cat)animal;
        cat.catchMoue();
    }
}

接口的构造

package com.iteasyup.javase;

public interface Lock {

    FangDaoMen fangDaoMen = new FangDaoMen();
    
    //常量，必须用public润饰，常量默认被public static final润饰，
    //常量名最好大写，不然有可能被误认为变量
    //用接口点的形式调用
    //不论是类下，还是接口下，常量必须赋值
    //如果在类上面定义一个常量，public static final不能省略
    public static final int A = 10;
    
    //形象办法，能够将修饰符（不仅仅是拜访修饰符）省略
    //默认存在修饰符public abstract，能够写，也能够不写
    void lock();
    void unlock();
}

过程休眠的sleep和wait的区别以及死锁

package com.iteasyup.javase;

public class T1 extends Thread {

    //sleep和wait的办法
    //1.sleep是Thread类下的办法，wait是object类下的办法
    //2.sleep有自醒工夫，被动开释锁，wait须要被notify唤醒，不被动开释锁
    
    //死锁：因为同步代码块的嵌套，导致两把锁相互抢占彼此的资源，导致程序无奈进行，此时称作死锁。因而最好不要对锁进行嵌套。
    //锁必须找同一个人，必须写援用类型（对象或者字符串）

    @Override
    public void run() {
        synchronized ("aa") {
            System.out.println("1");
            synchronized ("bb") {
                System.out.println(2);
            }
        }
    }
}


package com.iteasyup.javase;

public class T2 extends Thread{

    @Override
    public void run() {
        synchronized ("aa") {
            System.out.println(3);
            synchronized ("bb") {
                System.out.println(4);
            }
        }
    }
}

//sleep的创立形式
package com.iteasyup.javase;

public class Buyer extends Thread{

    @Override
    public void run() {
        for(;;) {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            if (Market.goods == 0) {
                System.out.println("曾经没有货物啦！");
                break;
            }
            Market.goods -= 5;
            System.out.println("买家买走货物，货物残余" + Market.goods + "份");
        }
    }
}


package com.iteasyup.javase;

public class T2 extends Thread {
    @Override
    public void run() {
        synchronized ("bb") {
            System.out.println(3);
            synchronized ("aa") {
                System.out.println(4);
            }
//            for (int i = 1; i < 21; i++) {
//                System.out.println("线程二"+i);
//            }
//            "aa".notify();
        }
    }

}


package com.iteasyup.javase;

public class T1 extends Thread{
    @Override
    public void run() {
        synchronized ("aa") {
            System.out.println(1);
            synchronized ("bb") {
                System.out.println();
            }
//            try {
//                "aa".wait();
//            } catch (InterruptedException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//            for (int i = 1; i < 21; i++) {
//                System.out.println("线程一"+i);
//            }
            
        }
    }

}

可变形参的用法

package com.iteasyup.javase;

public class Test {

    //可变形参，底层是数组
    public void f1(String...strings) {
        for (String string : strings) {
            System.out.println(string);
        }
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        test.f1("aa", "bb", "cc", "dd");
    }
}

控制台接值

package com.iteasyup.javase;

import java.util.Scanner;

public class 控制台接值 {
    
    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        
        System.out.println("请输出一个整数：");
        int a = in.nextInt();
        System.out.println(a);
        System.out.println("请输出一个小数：");
        double b = in.nextDouble();
        System.out.println(b);
        System.out.println("请输出一个姓名：");
        String name = in.next();
        System.out.println(name);
    }
}

疾速排序算法的Java代码实现

package Ji1;

public class QuickSort {
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];
 
        while (i<j) {
            //先看左边，顺次往左递加
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看右边，顺次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则替换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
 
        }
        //最初将基准为与i和j相等地位的数字替换
         arr[low] = arr[i];
         arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }
 
 
    public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

拦截器

package com.iteasyup.fifth.advice;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class CommonIntercepter implements HandlerInterceptor{
    
    /**
     * 一、拦截器和过滤器的区别
     * 1. 拦截器，只能拦挡发送给Controller的申请
     *    过滤器，能够拦挡发送给任何资源的申请
     * 2. 拦截器：因为属于Spring治理，因而其能够获取并注入Spring实例化的bean。也就是能够应用@Autowired
     *    过滤器：属于Web利用的组件，不会被Spring治理，因而无奈获取Spring容器中的bean实例。也就是不能够应用@Autowired
     * 3. 拦截器：是基于反射 + 动静代理来实现的。
     *    过滤器：是基于办法回调实现的
     * 4. 拦截器：不依赖Servlet容器（实质上，拦截器没有Tomcat也能工作）。
     *    过滤器：必须依赖Servlet容器
     * 5. 拦截器：能够拦挡申请的三个阶段：
     *           （1）申请发送到Controller之前；
     *           （2）申请被解决完，然而没有渲染前；
     *           （3）申请解决完，视图渲染后；
     *    过滤器：只能够拦挡申请发送到资源之前的阶段；
     */
    
    //在申请进入controller之前拦挡
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        System.out.println("preHandle execute...");
        return true;
    }

    //视图渲染前拦挡，在办法执行完，还没return，还没jsp
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle execute...");
    }

    //视图渲染后拦挡，jsp画面曾经进去后
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
    System.out.println("afterCompletion execute...");
    }
}

须要在springmvc.xml中实例化该类，而后配置拦挡门路
    <mvc:interceptors>
        <mvc:interceptor>
        <!-- /**拦挡所有申请，/a/b/*拦挡前面没有目录的，/**/a/**拦挡两头有目录是a的 -->
        <!-- 拦挡门路 -->
            <mvc:mapping path="/**" />
            <!-- 实例化拦截器类 -->
            <bean class="com.iteasyup.fifth.advice.CommonIntercepter"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

利用迭代器从collection中取出数据的形式

        //迭代器
        Iterator<String> it = coll.iterator();
        //汇合调用iterator办法，会返回迭代器对象，利用迭代器对象，帮忙咱们从汇合中取数据
        //迭代器能够这么了解：
        //每次判断从该汇合的第一条开始，判断是否有值，如果有就打印进去，并且把指针移到下一条
        //下一条同样执行这个操作，如果曾经没值了，就完结循环
        while (it.hasNext()) {
            //it.hasNext()：判断汇合中是否还有元素
            System.out.println(it.next());
            //it.next()：取出汇合中的下一条元素
        }

利用办法给以后过程命名以及取名和解决并发问题

package com.qita.javase;

public class TestTicket implements Runnable{

    //解决并发问题：
    //1.同步办法
    //2.同步代码块
    int ticket = 100;
    
    @Override
    public void run() {
        for(;;) {
            ticket();
        }
    }
    
    public synchronized void ticket()   {
        if (ticket >= 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "残余票数为" + ticket-- + "张");
        }
    }

    public static void main(String[] args) {
        
        Runnable r1 = new TestTicket();
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r1);
        Thread t3 = new Thread(r1);
        
        t1.setName("售票窗口一：");
        t2.setName("售票窗口二：");
        t3.setName("售票窗口三：");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

利用面向对象对数组进行赋值

package com.iteasyup.javase;

public class TestArray {

    int[] arr = new int[3];
    
    public void addArr(int a, int b , int c) {
        arr[0] = a;
        arr[1] = b;
        arr[2] = c;
        
    }
    
    public void selectArr() {
        for (int i : arr) {
            System.out.println(i);
        }
    }
    
    public static void main(String[] args) {
        TestArray s1 = new TestArray();
        s1.addArr(4, 56, 2);
        s1.selectArr();
    }
}

两种利用过程休眠打印工夫的形式

package com.iteasyup.javase;

public class Time implements Runnable {

    @Override
    public void run() {
//        int h;
//        int m;
//        int s;
//        for (h = 0; h < 60; h++) {
//            for (m = 0; m < 60; m++) {
//                for (s = 0; s < 60; s++) {
//                    System.out.println("当初工夫是：" + h + "时" + m + "分" + s + "秒");
//                    try {
//                        Thread.sleep(10);
//                    } catch (InterruptedException e) {
//                        // TODO Auto-generated catch block
//                        e.printStackTrace();
//                    }
//                    
//                }
//            }
//            
//            
//            
//        }
        
        for(int i = 0;;i++) {
            System.out.println("曾经过了"+ i/(3600 * 24 * 30 * 12) + "年" + i / (3600 * 24 * 30) % 13 + "月" + i / (3600 * 24) % 31 + "天" + i / 3600 % 25 + "时"+ i / 60 % 60 +"分" + i % 60 + "秒");
        }
        
    }
}

枚举类

package com.iteasyup.fifth.test;

import lombok.Getter;

@Getter
public enum Season {
//    总的来说，枚举类外面有公有的成员变量，有参结构器，以及get办法。
//    而后用有参构造方法创立本类的对象，并赋给相应的属性，该对象默认被public static final润饰
    
//    ①：enum和class、interface的位置一样
//    ②：应用enum定义的枚举类默认继承了java.lang.Enum，而不是继承Object类。枚举类能够实现一个或多个接口。
//    ③：枚举类的所有实例都必须放在第一行展现，不需应用new 关键字，不需显式调用结构器。主动增加public static final润饰。
//    ④：应用enum定义、非形象的枚举类默认应用final润饰，不能够被继承。
//    ⑤：枚举类的结构器只能是公有的。

    SPRING("和煦", "春暖花开"),
    SUMMER("酷热", "烈日炎炎"),
    AUTUMN("凉快", "秋高气爽"),
    WINTER("凛冽", "白雪皑皑");
    
    public String temporature; //温度
    
    private String description; //形容
    
    private Season(String temporature, String description) {
        this.temporature = temporature;
        this.description = description;
    }
}

面试可能会问到的一些问题

package com.iteasyup.javase;

public class Test {

    public static void main(String[] args) {
        
    //创立字符串
    //类的构造
    /*
     * 1.构造方法
     * 2.办法（静态方法，非静态方法）
     * 3.成员变量
     * 4.代码块（动态代码块，非动态代码块）(代码块中的内容就是当类被运行的时候就先被加载）
     * 5.外部类
     */
        
        //当父类和子类同时存在动态代码块、非动态代码块、结构器时程序执行程序
        //执行程序
        /*
         * 父类动态代码块
         * 子类动态代码块
         * 父类非动态代码块
         * 父类无参结构器
         * 子类非动态代码块
         * 子类无参结构器
         */

        //动态代码块,只能应用static润饰的内容
//        static {
//            
//        }
        
        //非动态代码块
//        {
//            
//            
//            
//        }
        
        //执行程序：动态代码块>非动态代码块>无参结构器
        //动态先加载，非动态创建对象的时候加载
        //动态代码块，存在于动态域中，只会被加在一块儿

        
        //外部类
        //也分为动态和非动态，
        //在非动态外部类中不能够写与任何与动态相干的货色
        //外部类也能够被拜访修饰符润饰
        class T01{
            int a = 10;
            public void f22() {
                System.out.println(a);
            }
        }
        
    //4个拜访修饰符:管制办法、变量拜访范畴
    /**
     * private:私有化，只能在以后类下应用
     * default:没有拜访修饰符的时候，默认被它润饰，然而如果写出default来的话会报错
     * protected:同包不同类能够拜访，如果跨包的话必须存在一个继承的关系，能力拜访
     * public:只有是保障在同一个我的项目下的任意类都能够拜访
     * 
     */
        
        
        /**
         *                     本类        同包不同类        跨包（父子类）        所有包所有类
         * priavate              √                ×                  ×                      ×
         * default              √                √                  ×                      ×
         * protected          √                √                  √                      ×
         * public              √                √                  √                      √
         */
        
        //拜访修饰符能够润饰的货色
        /**
         * 1.类
         * 2.一般办法
         * 3.成员变量
         * 4.结构器
         * 5.外部类
         */
        /*
         * 
         */
        
        //面试问题：
        
        //数组必须指明长度。
        //初始化成员变量有几种形式：
        //①显示初始化（间接赋值）
        //②默认初始化（成员变量有默认值）
        //③对象初始化（创建对象 对象.成员变量）
        //④结构器初始化
        //⑤代码块初始化
        //实例化 == 创建对象
        //请解释什么是实例变量和类变量
        //实例变量就是没有被static润饰的变量
        //类变量就是被static润饰的变量，随着类的加载而加载，存在于动态域中，不会反复加载
        //JavaBean
        //存在无参结构器的类，称之为JavaBean
        //pojo
        //带有get、set办法的类称之为pojo类

    String s1 = "Hello";
    String s2 = new String("java");
    System.out.println(s2);
    }
}

面向对象的个别办法调用和成员变量的赋值

package com.iteasyup.javase;

public class Student {

    //姓名
    String name;
    //
    int no;
    //学生的年龄
    int age;
    
    //好好学习
    //没有static须要应用类来调用
    public void study() {
        System.out.println("好好学习");
    }
    
    //学生
    public void showStudentLife() {
        System.out.println("逃课");
        System.out.println("挂科");
        System.out.println("谈恋爱");
    }
}

package com.iteasyup.javase;

public class StudentTest {

    public static void main(String[] args) {
        
        //创立学生对象
        Student s1 = new Student();
        s1.name = "刘吉";
        s1.age = 22;
        s1.no = 1001;
        s1.study();
        
        System.out.println(s1.name);
        System.out.println(s1.age);
        System.out.println(s1.no);
        
        //创立第二个学生对象
        Student s2 = new Student();
        s2.name = "珠兰";
        s2.age = 10;
        s2.showStudentLife();
        System.out.println("该学生的姓名为" + s2.name + "，她的年龄是" + s2.age + "岁");
        System.out.println(s2.no);
    }
}

全副数据类型以及正文形式

package com.iteasyup.javase;

/**
 * 
 * @author ji.liu
 * @since 2019.07.11
 */
public class 数据类型 {

    public static void main(String[] args) {
        
//        //java数据类型
//        //1.根本数据类型
//        //2.援用类型
//        
//        
//        /*
//         * 多行正文
//         * 根本数据类型8个
//         * ①整数型： byte    short    int    long
//         * ②浮点型float double
//         * ③布尔型boolean
//         * ④字符型char
//         * 
//         * 
//         * 
//         */
//        //字节类型
//        byte a = 10;
//        //a + 1 之后的后果是多少
//        //int 强转（大类型转换为小类型）byte
//        a =(byte)(a + 1);
//        System.out.println(a);
//        //java中存不存在一个数加1之后小于它自身
//        //比方byte的127加一会变成-128，相当于一个循环
//        
//        byte b = 127;
//        b += 1;
//        System.out.println(b);
//        
//        
//        //短整型
//        short s = 32767;
//        
//        //整型
//        int i = 1000000202;
//        
//        //长整型
//        long l = 123;
//        //超过int类型范畴的数，要在数值的前面加大写或小写的L
//        long p = 1777897139719237497L;
//        
//        //高精度
//        double d = 1.7947177383910299101838319;
//        //低精度
//        float f = 12390.332f;
//        
//        //布尔值
//        boolean b1 = true;
//        
//        //字符型
//        char c = 'a';
//        char c1 = '我';
//        char c2 = 122;
//        System.out.println(c2);
//        //字符在java外面用asc码
//        
//        char c3 = 25105;
//        System.out.println(c3);
//        System.out.println(c1);
//        
        //null是援用类型的默认值
        
        //&&和&都是并且
        //①&&如果左侧条件曾经不成立，就不执行右侧的条件，间接返回false
        //②&先判断符号左侧，即便为false也会判断右侧代码，最初返回false
        //&位运算符（与）（二进制都为1，则为1）
        //|（或）（二进制有1则为1）
        //^（异或）（二进制雷同为0，不同为1）,能够用来替换两个变量的数据
        //<< >>左移右移运算符
        
//        String s1 = null;
//            if (1 == 2 && s1.length() == 1)  {
//                System.out.println("胜利");
//            }else {
//                System.out.println("失败");
//            }
        
        int a = 10;
        int b = 20;
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
        System.out.println(a);
        System.out.println(b);
//        System.out.println(10 | 8);
        
        System.out.println(10 >> 2);
    }
}

全局变量和局部变量

package com.iteasyup.javase;

public class Person {

    String name;
    int age;
    String sex;
    
    //当成员变量和局部变量同名时，
    //应用this.来辨别谁是成员变量
    //this.示意以后类的对象
    //成员变量和局部变量和局部变量之间的区别
    //①局部变量定义在办法内，成员变量定义在办法外，类下
    //②局部变量必须赋值，成员变量有默认值
    
    public void changeName(String n) {
        name = n;
    }
    
    public void addAge() {
        age += 18;
    }
    
    public void showPerson() {
        System.out.println("此人姓名为：" + name + "；年龄：" + age + "岁；性别为：" + sex);
    }
    
    public static void main(String[] args) {
        
        Person p1 = new Person();
        Person p2 = new Person();
        
        p1.sex = "男";
        p1.changeName("刘吉");
        p1.addAge();
        p1.showPerson();
        p2.showPerson();
    }
}

如何从控制台取得数字定义数组

package com.iteasyup.javase;

import java.util.Scanner;

public class 第二种定义数组的形式 {

    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        
        //数组特点：
        //数组中存储的数据类型必须统一
        //数组定义的时候必须指明长度
        //定义数组
        int[] arr = new int[5];
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输出第" + (i + 1) + "个数：");
            arr[i]= in.nextInt();
        }
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

如何递归输入1-5

public static void main(String[] args) {
        //利用递归的形式，输入1~5
        m1(1);
    }
    public static void m1(int i) {
        System.out.println(i);
        i++;
        if (i == 6) {
            return;
        }
        m1(i);
    }

如何对set外面的数据进行排序

package com.iteasyup.javase;

import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {

    public static void main(String[] args) {
        
        //排序Set汇合中的数据
        //创立TreeSet实现类对象，重写hashCode、equals办法，重写toString
        //实现comparable接口，重写compareTo办法

        Set<Student> set = new TreeSet<>();
        
        Student s1 = new Student("小红", 21);
        Student s2 = new Student("小白", 24);
        Student s3 = new Student("小黑", 56);
        Student s4 = new Student("小花", 29);
        
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        
        System.out.println(set);
    }
}

package com.iteasyup.javase;

public class Student implements Comparable<Student> {

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

    @Override
    public int compareTo(Student o) {
        // TODO Auto-generated method stub
        return this.age - o.age;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

如何取得一个整数的个位、十位、千位的数字

package com.iteasyup.javase;

public class 取余数 {
public static void main(String[] args) {
    //1.求余数
    System.out.println(5 % 3);
    //2.求某个数的各个位数的值是多少
    int a = 12345;
    //个位
    System.out.println(a % 10);
    //十位
    System.out.println(a / 10 % 10);
    //百位
    System.out.println(a / 100 % 10);
    //千位
    System.out.println(a / 1000 % 10);
    //万位
    System.out.println(a / 10000 % 10);
    
    //判断10是否被3整除
//    if (10 % 3 == 0) {
//        System.out.println("能整除");
//    }
}
}

如何获取1—100中所有的素数

package com.iteasyup.javase;

public class 循环拓展题5 {

    public static void main(String[] args) {
        
        for (int i = 1; i < 101; i++) {
            int s = 0;
                for (int j = 1; j < i + 1; j++) {
                    if (i % j == 0) {
                        ++s;
                    }
                }
                
                if (s == 2) {
                    System.out.println("素数有："+ i);
                }
            }
        }
    }

如何进行冒泡排序以及如何把一个数组中符合要求的数字转移到另一个数组

package com.iteasyup.javase;

import java.util.Scanner;

public class 扩大题唱歌较量 {
    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        
        int[] a = new int[6];
        for (int i = 0; i < a.length; i++) {
            System.out.println("请输出第" + (i + 1) + "评委问题：");
            a[i] = in.nextInt();
        }
        
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - 1; j++) {
                int temp = 0;
                if (a[j] > a[j+1]) {
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        
        for (int i = 0; i < a.length; i++) {
            System.out.println("a的数组：" + a[i]);
        }
        
        int[] b = new int[a.length - 2];
        int j = 0;
        for (int i = 0; i < a.length; i++) {
            if (i != 0 && i != a.length - 1) {
                b[j] = a[i];
                j++;
            }
        }
        
        for (int i = 0; i < b.length; i++) {
            System.out.println("b数组：" + b[i]);
        }
        
        double sum = 0;
        for (int i = 0; i < b.length; i++) {
            sum = sum + b[i];
        }
        
        System.out.println("选手的均匀问题为：" + sum/b.length + "分");
        
        另一种冒泡：
        int i;
        int j;
        int a[] = {5, 9, 6, 8, 7};
        
        for (i = 0; i < a.length - 1; i++) {
            int k = i;
            for (j = i; j < a.length; j++) {
                if (a[j] < a[k]) {
                    k = j;
                }
                int temp = a[i];
                a[i] = a[k];
                a[k] = temp;
            }
        }
        for (i = 0;  i < a.length; i++) {
            System.out.println(a[i] + "");
            System.out.println();
        }
    }
}

如何进行字符串之间的比拟

package com.iteasyup.javase;

import java.util.Scanner;

public class 条件分支语句 {
    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        //如果输出的问题大于60，输入及格，否则输入不及格
        System.out.println("请输出学生问题：");
        double score = in.nextDouble();
        //if(条件：布尔表达式) {代码执行体}
//        if (score >= 60) {
//            System.err.println("及格");
//        } else {
//            System.out.println("不及格");
//        }
        
        if (score >= 90 && score <= 100) {
            System.out.println("优良");
        }else if (score >= 80 && score < 90) {
            System.out.println("良好");
        }else if (score >= 60 && score < 80) {
            System.out.println("及格");
        }else if (score >= 0 && score <60) {
            System.out.println("不及格");
        }else {
            System.out.println("问题必须在0-100之间");
        }
    }
}

如何让最初一个被打印的数前面没有逗号或其它字符

package com.iteasyup.javase;

public class 数组程序5 {

    public static void main(String[] args) {
        
        int[] a = {2,2,5,5,3};
        for (int i = 0; i < a.length; i++) {
            if (i == a.length - 1) {
                System.out.print(a[i]);
            }else {
            System.out.print(a[i] + "，");
            }
        }    
    }
}

public static void f1(String s) {
        String[] strings = s.split(",");
        int count = 0;
        for (int i = 0; i < strings.length; i++) {
            int a = Integer.valueOf(strings[i]);
            if (a % 2 != 0) {
                count++;
                if (count == 1) {
                    System.out.print(a);
                }else {
                    System.out.print("," + a);
                }
            }
        }
    }

如何在保障安全性的前提下对成员变量进行赋值

package com.iteasyup.javase;

public class User {

    String cardNo;//卡号
    private double money;//钱
    String password;//明码
    
    //公开给成员变量赋值的办法
    public void setMoney(double money) {
        if (money >= 0) {
            this.money = money;
        }
        else {
            System.out.println("输出谬误");
        }
    }
    
    //取值
    public double getMoney() {
        return money;
    }
}

package com.iteasyup.javase;

public class UserTest {

    public static void main(String[] args) {
        
        //创立用户对象，给用户对象赋值
        User user = new User();
        user.cardNo = "123456789";
        user.setMoney(-1000);
        user.password = "1qaz";
        
        System.out.println(user.cardNo);
        System.out.println(user.getMoney());
        System.out.println(user.password);
    }
}

如何在应用有参构造方法的时候，从控制台接值

package com.lingyige.javase;

public class Student {

    int no;
    int age;
    String name;
    
    public Student(int no, int age, String name) {
        this.no = no;
        this.age = age;
        this.name = name;
    }
    
    public void showStudent() {
        System.out.println("这个学生名字叫做：" + name + "，年龄为：" + age + "，学号为：" + no);
    }
}

package com.lingyige.javase;

import java.util.Scanner;

public class StudentTest {

    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        System.out.println("请输出编号：");
        int no = in.nextInt();
        System.out.println("请输出年龄：");
        int age = in.nextInt();
        System.out.println("请输出姓名：");
        String name = in.next();
        Student student = new Student(no, age, name);
        
        student.showStudent();
    }
}

三目运算符

package com.iteasyup.javase;

import java.util.Scanner;

public class 三目运算符 {
    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        
        //利用三目运算符实现比拟两个数的大小
        System.out.println("请输出第一个值：");
        int a = in.nextInt();
        System.out.println("请输出第二个值：");
        int b = in.nextInt();
        System.out.println("请输出第三个值：");
        int c = in.nextInt();
        // String max = a > b ? "最大值" + a : "最大值" + b;
        // System.out.println();
        
        //求三个数的最大值
        System.out.println((a > b ? a : b) > c ? (a > b ? a : b) : c);
        //业务的时候用if语句，然而写更底层的时候应用三目运算符
    }
}

删除list中反复的元素

public static List removeDuplicate(List list)  {       
          for  (int i = 0; i < list.size() - 1; i ++ )  {       
              for  (int j = list.size() - 1; j > i; j --)  {       
                   if  (list.get(j).equals(list.get(i)))  {       
                      list.remove(j);       
                    }        
                }        
              }        
            return list;       
        }

设计模式：单例模式

package com.jihezonghlianxi.javase;

public class User {

    String accont;
    String pasword;
    
    //如何实现单例模式的设计模式
    
    //1.私有化结构器
    private User() {

    }
    
    //2.创立公有动态的final润饰的本类对象
    private static final User USER = new User();
    
    //3.公开的动态的返回值为本类对象的办法
    public static User getUser() {
        return USER;
    }
}

package com.jihezonghlianxi.javase;

public class UserTest {

    public static void main(String[] args) {
        
//        User user = new User();
//        user.accont = "a";
//        user.pasword = "b";

        User user = User.getUser();
        user.accont = "a";
        user.pasword = "b";
        User user1 = User.getUser();
        user1.accont = "a";
        user1.pasword = "b";
    }
}

设计模式：适配器模式

package com.jihezonghlianxi.javase;

public interface TestDao {

    //为什么要用适配器模式：
    //1.当接口增加办法的时候，实现该接口的类，外面的办法也须要增加。
    //2.如果继承实现多个接口的话，就会有本人不想要的办法。

    //如何实现适配器模式
    //1.找到1个实现类实现接口，重写接口下的所有办法
    //2.找1个子类继承实现类，只重写你想要的形象办法
    void f1();
    void f2();
    void f3();
    void f4();
    void f5();
}

package com.jihezonghlianxi.javase;

public class TestDaoImpl implements TestDao {

    @Override
    public void f1() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void f2() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void f3() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void f4() {
        // TODO Auto-generated method stub
    }

    @Override
    public void f5() {
        // TODO Auto-generated method stub
    }
}

package com.jihezonghlianxi.javase;

public class TestChild extends TestDaoImpl{

    @Override
    public void f1() {
        // TODO Auto-generated method stub
        super.f1();
    }
    
    @Override
    public void f2() {
        // TODO Auto-generated method stub
        super.f2();
    }
}

输入斐波那契数列

利用数组和for循环输入斐波那契数列
package com.iteasyup.javase;

import java.util.Scanner;

public class 斐波那契数列 {

    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        
//        //1 1 2 3 5 8 13
//        int[] a = new int[10000];
//        a[0] = 1;
//        a[1] = 1;
//        
//        for (int i = 2; i < a.length; i++) {
//            a[i] = a[i - 2] + a[i - 1];
//        }
//        
//        System.out.println("请输出你想晓得第几位数字：");
//        
//        int b = in.nextInt();
//        
//        System.out.println("该位数字是：" + a[b]);
        
//        int[] arr = new int[5];
//        arr[0] = 1;
//        arr[1] = 1;
//        for (int i = 2; i < arr.length; i++) {
//            arr[i] = arr[i - 1] + arr[i - 2];
//        }
//        
//        System.out.println(arr[5 - 1]);
    }
}

//利用递归的形式输入斐波那契数列
package com.iteasyup.javase;

public class Fibonacci {

    public static void f1(int[] a, int i) {

        a[i] = a[i - 1] + a[i - 2];
        System.out.println(a[i]);
        i++;
        if (i > 1000) {
            return;
        }
        f1(a, i);
    }
    
    
    public static void main(String[] args) {
        //利用递归的形式，输入一个斐波那契数列
        int[] a = new int[10000];
        a[0] = 1;
        a[1] = 1;
        int i = 2;
        f1(a,i);
        
    }
}

输入流的应用

package com.iteasyup.javase;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class TestOutputStream {

    public static void main(String[] args) throws IOException {
        
        //1.找到文件
        File file = new File("D:\\aa.txt");
        
        //2.创立字节输入流
        OutputStream os = new FileOutputStream(file);
        
        //3.写出数据
        String s1 = "helloworld";
        os.write(s1.getBytes());
        
        //4.敞开流
        os.close();
    }

    private static OutputStream FileOutputStream(File file) {
        // TODO Auto-generated method stub
        return null;
    }
}

输出流+buff

package com.iteasyup.javase;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class TestBufferedInputStream {

    public static void main(String[] args) throws IOException {
        
        //1.创立file对象
        File file = new File("D:\\bb.txt");
        
        //2.创立字节流
        InputStream is = new FileInputStream(file);
        
        //3.创立缓冲流
        BufferedInputStream bis = new BufferedInputStream(is);
        
        //4.读数据
        int a = 0;
        while ((a = bis.read()) != -1) {
            System.out.println((char)a);
        }
        
        //5.敞开
        bis.close();
        is.close();
    }
}

输出流的应用

package com.iteasyup.javase;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class TestInputstream {

    public static void main(String[] args) throws IOException {
        
        //D:\aa.txt
        //1.找到操作的文件
        File file = new File("D:\\aa.txt");
        //2.创立字节输出流
        InputStream is = new FileInputStream(file);
        
        //3.通过流读数据
        int result = 0;
        while(((result) = is.read()) != -1) {
            System.out.println((char)result);
        }
        
        //4.敞开流
        is.close();
    }
}

数据类型以及如何进行字符串之间的比拟

package com.iteasyup.javase;

public class Test2 {

    public static void main(String[] args) {
        //java中数据类型的定义
        //1.定义整数类型
        int a = 10;
        int b = 20;
        int c = a / b;
        //ctrl+E能够过错，并批改
        //syso中看a的类型而不是值
        System.out.println(c);
        
        //2.小数类型
        //double
        double d = 1.5;
        double e = 2;
        System.out.println(d / e);
        
        //判断a和b之间的大小
        //输入true或者是false这样的值的后果称之为布尔值
        //失去布尔值的表达式称之为布尔表达式
        //罕用的逻辑运算符：> < >= <= == !=
        //= 和 ==之间的区别
        //=：代表赋值的意思
        //==：代表数字类型之间的比拟
        System.out.println(a != b);
        
        //布尔类型定义
        //boolean
        
        boolean b1 = true;
        boolean b2 = false;
        
        //字符串类型
        //所有String类型和其它任意类型做加法运算示意拼接，不能去做加法之外的运算
        //String
        String s1 = "java";
        String s2 = "1001";
        System.out.println(s1 + a);
        
        //判断s1和s2不相等
        System.out.println(!s1.equals(s2));
        //判断s1和s2相等
        System.out.println(s1.equals(s2));
        
        //.eauals()的形式比拟是否相等
        //若比拟不相等，在比拟的变量前加上!代表取反的意思
        
        //展现人的手机号
        //int 的取值范畴-2^31——2^31
        String v = "13599123456";
    }
}

数据类型转换，装箱，拆箱，强转

package com.iteasyup.javase;

public class TestCollection {

    //包装类：将根本数据类型定义为援用类型
    
    public static void main(String[] args) {
        
        //int的包装类型
        Integer i = 100;
        //char的包装类型
        Character c = 'a';
        
        //Byte Short Long Double Float Boolean
        
        //字符串与int之间的互相转换
        int a= 10;
        //将整数类型转换成字符串类型
        String s1 = String.valueOf(a);
        System.out.println(s1);
        
        String s2 = "123";
        //将字符串转换成整数
        
        Integer i1 = Integer.valueOf(s2);
        //主动拆箱：援用类型转换成根本类型
        int a1 = i1;
        
        //主动装箱：根本数据类型变成援用类型
        int a2 = 100;
        Integer i2 = a2;
        //另一种装箱办法
        int a3 = Integer.parseInt(s2);
        
        //强转：大类型转小类型
    }
}

数组

package com.iteasyup.javase;

public class 数组 {

    public static void main(String[] args) {
        
        //定义一个整数类型的数组
        int[] arr = {2,45,1,5};
        arr[1] = 3;
//        System.out.println(arr[0]);
//        System.out.println(arr[1]);
//        System.out.println(arr[2]);
//        System.out.println(arr[3]);
        
        //利用循环的形式遍历数组中的数据
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

条件分支语句

package com.iteasyup.javase;

import java.util.Scanner;

public class 条件分支语句 {
    static Scanner in = new Scanner(System.in);
    public static void main(String[] args) {
        //如果输出的问题大于60，输入及格，否则输入不及格
        System.out.println("请输出学生问题：");
        double score = in.nextDouble();
        //if(条件：布尔表达式) {代码执行体}
//        if (score >= 60) {
//            System.err.println("及格");
//        } else {
//            System.out.println("不及格");
//        }
        
        if (score >= 90 && score <= 100) {
            System.out.println("优良");
        }else if (score >= 80 && score < 90) {
            System.out.println("良好");
        }else if (score >= 60 && score < 80) {
            System.out.println("及格");
        }else if (score >= 0 && score <60) {
            System.out.println("不及格");
        }else {
            System.out.println("问题必须在0-100之间");
        }
    }
}

通过流和反射来创建对象并调用一些私有化的变量和办法

package com.iteasyup.javase;

public class Student {

    int no;
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    private void show(String s1) {
        System.out.println(s1);
    }
}

package com.iteasyup.javase;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestStudent {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
        //创建对象
//        Student student = new Student();
//        student.setAge(20);
//        student.setName("小明");
//        System.out.println(student.getName());
//        System.out.println(student.getAge());
        
        //获取到想要操作的这个类的字节码
        
//        System.out.println(class1);
//        
////        Class<Student> class2 = (Class<Student>)new Student().getClass();    
//        
////        Class<Student> class3 = (Class<Student>) Class.forName("com.iteasyup.javase.Student");
//        
//        System.out.println(class1 == class2);
//        System.out.println(class2 == class3);
//        System.out.println(class1 == class3);
        
////        Class<Student> class1 = Student.class;
        //通过反射创建对象
        Student student = class1.newInstance();
        //获取私有化的成员变量
        Field[] declaredFields = class1.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
        }
        
        //获取非私有化成员信息
        Field[] fields = class1.getFields();
        for (Field field2 : fields) {
            System.out.println(field2);
        }
        
        //获取setname办法
        Method[] methods = class1.getMethods();
        
        for (Method method : methods) {
            System.out.println(method);
        }
        
        Method method = class1.getMethod("setName", String.class);
        method.invoke(student, "小红");
        
        Method method2 = class1.getMethod("getName");
        System.out.println(method2.invoke(student));
        
        //执行私有化的办法
        Method method3 = class1.getDeclaredMethod("show", String.class);
        method3.setAccessible(true);
        method3.invoke(student, "helloworld");
    }
}

同一个class中进行办法调用

package com.iteasyup.javase;

public class TestMethod {

    public static void main(String[] args) {
        //1.输入1-10的数字
        TestMethod.f1();
        //2.输入1-10之间的偶数
        //3.输入1-10之间的奇数
        //4.输入1-10数字
        
        //办法的构造
        //public拜访修饰符，示意公开，任何人都能够调用，同理还有private，只能在以后类下应用
        //static类拜访
        //void示意返回值类型
        //main示意办法的办法名
        //()外面称之为参数
        //{}外面的货色就是办法的执行体
    }
    //办法
    //static类调用
    public static void f1() {
        for (int i = 1; i < 11; i++) {
            System.out.println(i);
        }
    }
    
    public static void max(int c,int d) {
        //局部变量
        int a = c;
        int b = d;
        System.out.println(a > b ? a : b);
    }
}

文件基本操作

package com.iteasyup.javase;

import java.io.File;

public class TestFile {

    public static void main(String[] args) {
        
        //D:\\VS Code\\a.txt
        
        //D:\VS Code\a.txt
        File file = new File("D:/VS Code/a.txt‪‪");
        //获取文件名字
        System.out.println(file.getName());
        //获取文件的长度
        System.out.println(file.length());
        //文件是否存在
        System.out.println(file.exists());
        //获取绝对路径
        System.out.println(file.getAbsolutePath());
        //获取相对路径
        System.out.println(file.getPath());
        //删除
//        System.out.println(file.delete());
        
        File file2 = new File("D:\\bb.txt");
        System.out.println(file2.getName());
        System.out.println(file.length());
    }
}

线程的两种创立形式

package com.iteasyup.javase;

public class Customer1 implements Runnable {

    @Override
    public void run() {
        int money = 1000;
        for (int i = 0; i < 10; i++) {
            money -= 100;
            System.out.println("以后账户余额：" + money);
        }
    }
}


package com.iteasyup.javase;

public class Customer2 extends Thread {

    @Override
    public void run() {
        int money = 1000;
        for (int i = 0; i < 10; i++) {
            money += 100;
            System.out.println("以后账户余额：" + money);
        }
    }
}


package com.iteasyup.javase;

public class TestCustomer {

    public static void main(String[] args) {
        Runnable c1 = new Customer1();
        Thread c2 = new Customer2();
        
        Thread cc = new Thread(c1);
        cc.start();
        c2.start();
    }
}

有参构造方法的应用

package com.iteasyup.javase;

public class Animal {
    
    //成员变量
    String name;
    int age;
    
    //结构器：与类名同名，并且没有返回值类型的办法成为构造方法
    //作用：①实例化（创建对象）②初始化成员变量（给成员变量赋值）
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void showAnimal() {
        System.out.println("动物的名字叫做" + name + "年龄为" + age + "岁");
    }
    
    public static void main(String[] args) {
        Animal animal = new Animal("小红", 10);
        animal.showAnimal();
    }
}

有参构造方法和无参构造方法的应用的一个例子

package com.lingyige.javase;

public class Film {

    String filmName;
    String actorName;
    int money;
    
    public Film() {
        filmName = "这个杀手不太冷";
        actorName = "让·雷诺";
        money = 0;
    }

    public Film(String filmName, String actorName, int money) {
        this.filmName = filmName;
        this.actorName = actorName;
        this.money = money;
    }
    public void addMoney(int day) {
        money += 300000 * day;
    }
    public void showFilm() {
        System.out.println(filmName + "这个电影很不错，主演是：" + actorName + "，它的票房总额是：" + money);
    }
}

package com.lingyige.javase;

public class FilmTest {

    public static void main(String[] args) {
        Film f1 = new Film();
        f1.addMoney(9);
        f1.showFilm();
        
        Film f2 = new Film("这个手刹不太灵", "小强", 0);
        f2.addMoney(8);
        f2.showFilm();
    }
}

有参数的办法调用

package com.iteasyup.javase;

public class TestParameter {

    //需要：写出一个办法示意用钱买了一瓶10元的水
    //求剩下多少钱                       //形参：模式上的参数

    public static void selectMoney(int money) {
        money -= 10;
        System.out.println("残余" + money + "元");
    }
    
    public static void main(String[] args) {
        //在java中，参数的传递形式是值传递，而不会关注变量名
        //实参：理论的参数
        int a = 100;
        selectMoney(a);        
    }
}

留神不要将有参无参构造方法和办法混同，两者的应用并不抵触

package com.lingyige.javase;
public class People {

    String name;
    int age;
    String sex;
    double height;
    
    public People() {
        name = "小刚";
        age = 24;
        sex = "男";
        height = 160.0;
    
    }
    
    public void talk(String t) {
        System.out.println(t + "说了一句受死吧");
    }
    
    public void changeName(String n) {
        name = n;
    }
    
    public void addHeight(double n) {
        height += n;
    }
    
    public void showPeople() {
        if (height >= 180) {
            System.out.println("他，身高" + height + "无余，孔武有力，年仅" + age + "岁，就以傲人的身高鸟瞰众生，他就是" + name);
        }
        else {
            System.out.println("他，虽身高只有" + "height" + "，却有着惊人的速度和灵活性，年仅" + age + "岁，就能疾速游走于公交人群中，他就是" + name);
        }
    }
}

package com.lingyige.javase;
public class PeopleTest {

    public static void main(String[] args) {
        
        People people = new People();
        people.talk("大吉哥");
        people.changeName("vip");
        people.addHeight(180.0);
        people.showPeople();
        
    }
}