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();
}
}
网友评论