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);
}
}
}
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());
}
}
}
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 循环先执行后判断，肯定至多会有一个后果
}
}
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);
}
}
}
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;
}
}
}
}
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");
}
}
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);
}
}
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();}
}
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);
}
}
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();}
}
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();}
}
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();}
}
}
}
}
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);
}
}
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);
}
}
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;
}
}
}
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++;
}
}
}
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);
}
}
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();}
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);
}
}
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>
// 迭代器
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]);
}
}
}
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);
}
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("能整除");
// }
}
}
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 语句，然而写更底层的时候应用三目运算符
}
}
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;
}
}
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");
}
}
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();}
}