笔记整理
一、数组定义使用
package arraytest;
//Java基础之数组
public class L01 {
public staticvoid main(String[] args) {
Stringname ="111";
//初始化的三种方式
//第一种：声明时直接赋值
String[]names={"one","er"}; //声明一个数组，
int []ages; //声明一个整形数组
L01 ll[]; //声明一个对象数组
String[][]classe={
{"张三","李四","王五"},//第一个数组元素，班级1
{"小赵","小王","小韩"}//第二个数组元素，班级2
}; //二维数组定义
//第二种数组赋值方式
ages =new int[10];
ages[0]=10;//对0号元素赋值
for(int i=0;i<10;i++)
ages[i]=i; //设置数组元素的值
System.out.println(ages[2]);//取出下标为2的数组的元素
//为对象数组赋值
//第三种方式，给数组元素直接赋值
ll= new L01[]{new L01(),new L01()};
System.out.println(names);
//访问二维数组
System.out.println(classe[0][1]);//班级1的第二个同学
//System.out.println(classe[1][2]);//班级2的第三个同学
//遍历一个数组中的所有元素
//数组是一个特殊的对象，length=数组元素的个数
//ArrayIndexOutOfBoundsException 数组下标越界，也不能赋值
for (int i = 0; i < names.length;i++) {
System.out.println(names[i]);
}
}
}
二、java io 流读取文件：
package arraytest;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class L02 {
/**
* 复制文件
*
* @param srcName
* 原始文件路径
* @param targetNmae
* 目标文件路径
*
*/
public staticvoid main(String[] args) {
L02 l02 =new L02();
l02.copy("C:\\垃圾.png", "D:\\垃圾.png");
}
public voidcopy(String srcName, String targetNmae) {
//srcNmae->读取-（程序）->写入targetName
byte[] buf= new byte[1024]; // 字节缓冲区
int len =0; // 每次读取的字节数
FileInputStreamin = null;
FileOutputStreamout = null;
try {
in =new FileInputStream(srcName); // 输入
out =new FileOutputStream(targetNmae);// 输出
while((len = in.read(buf)) > 0) { // 读一次
out.write(buf,0,len);
}
in.close();
out.close();
} catch(Exception e) {
e.printStackTrace();
}
}
}
三、Java集合基础：
package arraytest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class L03 {
public staticvoid main(String[] args) {
//集合 模板 数组
//List（可变数组，有序）、Set（堆，无序）、Map（键值对、映射）:都是接口
//List->ArrayList、LinkedList(链表):泛型
//Java中数据类型：1）基本类型（整数，浮点型，布尔值）、2）引用类型
//集合中不能放基本类型
//数据类型转换为引用类型：int->Integer float->Floatdouble->Double long->Long boolean->Boolean
List list = new ArrayList();//object
list.add(1); //int->Integer 自动装箱 list.add(1); =list.add(Integer(1));
//运行时异常：编译时不出错，但是在运行时出现错误
//int i = (int) list.get(1); //Integer->int 自动拆箱
list.add("one");
//泛型：泛型是类的模板，类是对象的模板。
//吧普通集合转换成泛型，避免出现运行时异常，泛型产生的动机：吧运行时异常转化在编译时错误
List<Integer> list1 = newArrayList<Integer>();
list.add(1); //如果 list.add("one") 在上面规定是Integer如果在下面写成字符串是就会报错，就不会出现运行时异常
int i1 =list1.get(0);
//Hash码：检验数据的完整性，避免出现数据的修改，变化。
//HashSet<>：不会存储重复的值
Set<String>set = new HashSet<String>();
set.add("one");
set.add("one");
set.add("two");
//遍历set集合
for(String item : set) { //增强的for循环，item是循环变量
System.out.println(item);
}
System.out.println(set.size());
//Map集合：键、值要一一对应
Map<String, Integer> map = newHashMap<String,Integer>();
map.put("第一个", 1);
map.put("第二个", 2);
int name =map.get(1);
int name2 = map.get(2);
//ListView（列表） - ArrayAdapter（适配器）->List
}
}
四、Java 程序流程 递归操作
package arraytest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class L04 {
/**
* 列出（打印到控制台）指定文件的内容
* D:/test System.out.println();
* public voidshowFileName(String dirName);//递归:自己调用自己
* @param
* @throws IOException
*/
//输出文件内容
// public static void main(String[] args) throws IOException {
// FileInputStream fis =newFileInputStream("C:\\poem.txt");
// byte[]buff = new byte[1024];
// inthasRead = 0;
// while((hasRead = fis.read(buff)) != -1) {
// System.out.println(newString(buff, 0, hasRead));
// }
// fis.close();
// }
public staticvoid main(String[] args){
L04 ll =new L04();
ll.showFileName("E:\\移动开发");
}
public voidshowFileName(String dirName) {
File fis =new File(dirName);
File[]childFile = fis.listFiles();
for (int i= 0;childFile !=null && i < childFile.length; i++) {
System.out.println(childFile[i].getName());
if(childFile[i].isDirectory()){
showFileName(childFile[i].getPath());
}
}
}
}
五、Java 程序流程控制 循环 for while dowhile
package money;
public class L02 {
public static void main(String[] args) {
//循环 程序：数据结构+算法
//for：万能循环
//循环1、循环固定的次数
//表达式1；表达式2；表达式3
//表达式1：初始化表达式
//表达式2：条件表达式
//表达式3:修改循环变量
for(int i=1;i<100;i++){
System.out.println(i);
}
//1轮：1 -> 2 ->循环体 ->3
//2轮：2 -> 循环体 ->3
//....
//99轮：2->循环体->3 i=99
//100轮:2 -> 循环体->3 i=100
//101轮：2->结束
//循环2
for(;;){}
//表达式1：判断->（成功）->循环体->（失败）->结束
// while (表达式1) {
// 循环体
}
//循环体 表达式1：->判断->（成功）->继续->（失败）->结束
// do {
// 循环体
// } while (表达式1);
}
}
六、计算质数之和
package money;
public class L04 {
public staticvoid main(String[] args) {
L04 n=newL04();
int num=n.sum(2,10);
System.out.println("质数和："+num);
}
publicint sum(int minVal,int maxVal) {
int sum=0;
if(minVal<1 || maxVal<1 || minVal >= maxVal) {
thrownew RuntimeException("参数不合法");
}
for(inti=minVal;i<=maxVal;i++){
int j;
for(j=minVal;j<i;j++){
if(i%j==0){
break;
}
}
if(i==j) {
sum +=j;
}
}
return sum;
}
}
七、统计某两个数之间的所有奇数和和所有偶数和：
package money;
/**
* 分别统计minVal-maxVal之间的质数之和
* 分别统计minVal-maxVal之间的奇数和偶数之和
* 如果minVal <= maxVal才进行计算
* 否则，抛出异常throw new RuntimeException("参数不合法")
* @param minVal 最小值（包含）
* @param minVal最大值（包含）
* @return 数组，0号元素是奇数和，1号元素的偶数和
*
*/
public class L03 {
public staticvoid main(String[] args) {
L03 ll=newL03();
int[] nums=ll.sum(1,10);
System.out.println("奇数和："+nums[0]+",偶数和："+nums[1]);
}
public int[]sum(int minVal,int maxVal) {
intousum=0;
intjisum=0;
//判断minVal是否合法
//奇数判断条件：if(minVal % 2 !=0)
if(minVal<0 || maxVal<0 || minVal>=maxVal) {
thrownew RuntimeException("参数不合法");
}
for(int i=minVal;i<=maxVal;i++){
if(i%2 ==0) {
ousum += i;
}else{
jisum += i;
}
}
int[]result = new int[]{jisum,ousum};
returnresult;
}
}
八、计算工人扣税后的工资
package money;
public class L01 {
public static void main(String[] args) {
// double money= 6000 ;
L01 ll = newL01();
System.out.println(ll.calc(11000));//输入的工资金额
}
// public doublecalc(double money){
// doublesum = money - 3500;//征税工资
// double rat = 0;
// doubletotal = 0;
// if(money>= 8500){//0.15
// total= sum * 0.15;
// }elseif(money >= 5000) {//0.1
// total= sum * 0.1;
// }elseif(money >= 3500) {//0.05
// total= sum * 0.05;
// }else{
// total= 0;
// }
// returntotal;
// }
//sum = money- 3500
//0-500 5%
//500-2000 10% 扣除25 5500:500*0.05+1500*0.1-25
//2000-5000 15% 扣除125
//5000-20000 20% 扣除375
//20000-40000 25% 扣除1350
//40000-60000 30% 扣除3375
//60000-80000 35% 扣除6375
//80000-10000040% 扣除10375
//100000以上 45% 扣除15375
public doublecalc(double money){
doubletotal = 0;//要交的税金总额
doublesum = money - 3500;//要征税的工资
doublesum0 = 0; //扣除工资
if(sum -100000 > 0){
total= total + (sum - 100000)*0.45;//100000以上 45% 扣除15375
sum0 =15375;
sum=100000;//100000以下计税工资
}
if(sum -80000 > 0 && sum - 100000 <= 0) {
total= total + (sum -80000)*0.4;//80000-100000 40% 扣除10375
if(sum0==0)sum0 = 10375;
sum=80000;//80000以下计税工资
}
if(sum -60000 > 0 && sum - 80000 <= 0) {
total= total + (sum -60000)*0.35;//60000-80000 35% 扣除6375
if(sum0==0) sum0 = 6375;
sum=60000;//60000以下计税工资
}
if(sum -40000 > 0 && sum - 60000 <= 0) {
total= total + (sum -40000)*0.3;//40000-60000 30% 扣除3375
if(sum0==0)sum0 =3375;
sum=40000;//40000以下计税工资
}
if(sum -20000 > 0 && sum - 40000 <= 0) {
total= total + (sum -20000)*0.25;//20000-40000 25% 扣除1350
if(sum0==0)sum0 = 1350;
sum=20000;//20000以下计税工资
}
if(sum -5000 > 0 && sum - 20000 <= 0) {
total= total + (sum -5000)*0.2;//5000-20000 20% 扣除375
if(sum0==0)sum0 = 375;
sum=5000;//5000以下计税工资
}
if(sum -2000 > 0 && sum - 5000 <=0) {
total= total + (sum -2000)*0.15;//2000-5000 15% 扣除125
if(sum0==0)sum0 = 125;
sum=2000;//2000以下计税工资
}
if(sum -500 > 0 && sum - 2000 <=0) {
total= total + (sum - 500)*0.1; //500-2000 10% 扣除25
if(sum0==0)sum0 = 25;
sum=500;//500以下计税工资
}
if(sum -500 <= 0) {
total= total + sum *0.05;//0-500 5%
}
returntotal-sum0;
}
}
九、Java 基础之日期：
package datePractice;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Dateexpression {
public staticvoid main(String[] args) throws Throwable{
//java.util.Date java.sql.Date
//时间是一个数字、格式化时间 SimpleDateFormat
SimpleDateFormatdf1=new SimpleDateFormat("yyyy年MM月dd日hh:mm:ss,SSSS");
SimpleDateFormatdf2=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss,SSSS");
SimpleDateFormatdf3=new SimpleDateFormat("yyyy-MM-dd");
for(int i=0;i<100;i++){
Datedate=new Date();
System.out.println(date.getTime()+",格式"+df1.format(date)+",格式二"+df2.format(date)+",格式"+df3.format(date));
//Thread.sleep(1000);
}
//获得当前系统时间
java.util.Datedate=new java.util.Date();
//获得当前时间的数字
longtime=date.getTime();
//将字符串转换为时间
Stringtimestr="1980-01-01";
java.sql.Datedate1=java.sql.Date.valueOf(timestr);
java.util.Datedate2=df3.parse(timestr);
//将时间转换为字符串
StringtiemStrResult=df1.format(date2);
System.out.println(tiemStrResult);
//日历 时间戳
Calendarc1=Calendar.getInstance(); //创建日历对象
System.out.println(df1.format(c1.getTime()));
c1.set(Calendar.MONTH, c1.get(Calendar.MONTH)+1);// 修改日历对象的时间为一个月后的这一刻c1.get(Calendar.Month)获取日历中当前月份
System.out.println(df2.format(c1.getTime()));
//------------------------------------------------------------------------
Calendarc2=Calendar.getInstance(); //创建日历对象
System.out.println(df1.format(c2.getTime()));
c2.set(Calendar.YEAR,c2.get(Calendar.YEAR)+1);// 修改日历对象的时间为一年后的这一刻c1.get(Calendar.YEAR)获取日历中当前年份
System.out.println(df1.format(c2.getTime()));
//------------------------------------------------------------------------
Calendarc3=Calendar.getInstance(); //创建日历对象
System.out.println(df1.format(c3.getTime()));
c3.set(Calendar.DATE,c3.get(Calendar.DATE)+1);// 修改日历对象的时间为一天后的这一刻c1.get(Calendar.DATE)获取日历中当前日
System.out.println(df1.format(c3.getTime()));
//------------------------------------------------------------------------
Calendarc4=Calendar.getInstance(); //创建日历对象
System.out.println(df1.format(c4.getTime()));
c4.set(Calendar.DATE,c4.get(Calendar.DATE)+70);// 修改日历对象的时间为70天后的这一刻c1.get(Calendar.DATE)获取日历中当前日
System.out.println(df1.format(c4.getTime()));
//------------------------------------------------------------------------
}
}
十、Java相关概念
面向对象 （上）
本次记录部分特别值得回味记忆的话
1所有类是引用对象。
2类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全都小写单词与单词之间不要使用任何分隔符。
3一个类中最常见的三种最常见的成员：构造器、成员变量、方法。
4 static修饰的成员不能访问没有static修饰的成员。
5一旦程序员为一个类提供了构造器，系统将不再为该类提供构造器
6 通常建议方法名以英文动词开头
7创建对象的根本途径是构造器
8 Java里的引用就是c里的指针，只是Java语言把这个指针封装起来，避免开发者进行烦琐的指针操作
9 this关键字总是指向调用该方法的对象，根据this出现的位置不同，this作为对象的默认引用有两种情形：
（1）构造器中引用该构造器正在初始化的对象
（2）在方法中引用调用该方法的对象
This可以代表任何对象，当this出现在某个方法体中时，它所代表的对象是不确定的，但它的类型是确定的：this所代表的只能是当前类的实例；只有当这个方法被调用时，它所代表的对象才被确定下来：谁在调用这个方法，this就代表谁。
10 Java编程时不要使用对象去调用static修饰的成员变量、方法，而是应该使用类去调用static修饰的成员变量、方法。
省略this前缀只是一个假象，虽然程序员省略了调用jump()方法之前的this，但实际上这个this依然是存在的。如果调用static修饰的成员，系统默认使用该类作为调用者；如果调用不用static修饰的成员，系统默认使用this作为调用者。
扫一扫
141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
