共计 38261 个字符，预计需要花费 96 分钟才能阅读完成。
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();}
}正文完