Test.java—编译javac（需要用到开发工具）--test.class—运行java—JVM(不同系统的JVM不一样)
1.1JDK
什么是JDK、JRE
JRE包括了JVK和java核心类库
JDK= JRE+开发工具集
1.2编写一个主方法
Public class Hello{
Public static void main(String[ ] args){
System.out.printIn(“hello world”);
}
}
//注意Sublime文件编码需要与控制台编码一致GBK编码，保存后才能生效，才能生成.class文件，运行时不需要带.class，因为类的名字就是hello
-
- Java开发注意事项
1.区分大小写
2.每条语句必须带分号，大括号成对出现，成对写，先写好
3.一个源文件中最多有一个public class类，其他类个数不限制（每一个类编译后都会对应产生一个.class文件），可以把main方法写入非public类中，运行时使用java 类的名称即可
4.如果源文件包含一个pulic主类，文件名称必须与主类名称一致
规范使用
-
-
Java常用转义字符（changechar）
-
| \t | 一个制表位 |
| \n | 换行符 |
| \’ | 一个’ |
| \” | 一个” |
| \r | 一个回车 |
public class changechar{
public static void main(String[ ] args){
System.out.println(“北京\t上海\t深圳”);
System.out.println(“北京\r清华大学”);//解读回车跟换行：回车不会换行，只会输出北京大学
System.out.println(“我说：\“失败只有一种\””); }//输出引号需要先转义
}
1.5代码注释
/* 定义两个整型数
输出其结果（注意多行注释内禁止嵌套多行注释）
*/
int n1 = 10;
int n2 = 20;
int num = n1+n2;
//求和
System.out.println("sum="+num);
//输出结果
文档注释
文档注释设置格式javadoc -d D:\\javadoc -author -version junesix.java
Javadoc标签
/**
* @author zhongminghui
* @version 1.0
*/
-
- Java代码规范
1.类、方法的注释，要以javadoc的方式来写
2.使用utf-8编码保存（GBK设置只是在dos命令窗口可以使用）
3.选中shift+tab整体左移
4.等号两边使用空格隔开
1.7常用dos命令
| 查看当前目录 | dir c:\user |
| 切换到其他盘 | cd c: |
| 切换到上一级 | cd.. |
| 切换到根目录 | cd \ |
| 表示创建一个目录 | md d:\\javadoc |
| 表示删除目录 | rd d:\\javadoc |
| 清屏 | cls |
相对路径与绝对路径
相对目录：从当前目录开始定位，形成的一个路径
绝对目录：从顶级目录D开始定位形成的目录
相对路径..\到上一级..\再到上一级\abc2\test.txt
绝对路径d:abc2\test.txt
-
第二章变量
2.1加号的使用
System.out.println(100+98);//198
System.out.println(100+3+"hello");//103hello
System.out.println("100"+98);//10098
System.out.println("hello"+100+3);//hello1003
2.2数据类型
基本数据类型（byte[1]/short[2]/int[4]/long[8]）(浮点类型、float[4]/double[8])(布尔型boolean[1]，存放true,false) (字符型char[2],存放单个字符‘a’)
Byte范围：-128~127
Short范围：-（2^15）~(2^15-1) -32768~32767
引用数据类型（类、接口、数组）string属于类
- java字段长度不受系统影响，都一样大
- java数据类型默认Int,若为长整型需要后面加L
- bit为最小的存储单位（基本单位），一个字节（byte）等于8个bit
- 浮点数在机器中存放形式，浮点数=符号位+指数位+尾数位：-3.4E38（小数都是近视值）
- 默认都是Int型，浮点型默认都是double,如果要float类型（float num1 = 1.1f）大小写F都行// double num1 = 1.1f 可以，小的可以放到大的空间，反之，则不能成立
Double num5 = .123 //可以省略0
double num1 = 1.1f//可以
System.out.println(5.12e2)//输出512.0，输出也是double型
System.out.println(5.12E-2)//0.0512
Double num9 = 2.123452231;//全部输出，精度更高
Float num10 = 2.123452231F;//会省略一部分
Double num11 = 2.7 ;
Double num12 = 8.1/2.7 ;//输出的会是一个 近视值，并非2.7
System.out.println(num12);//不能对两个运算过后的数进行比较
如if(num11==num12){
System.out.println(“相等”);
}
需要比较时
If(Math.abs( num11 - num12 ) < 0.00001){//定义小于多少就算相等
System.out.println(“差值小于我的规定范围，认为相等”);
}
Java API 文档//https://www.matools.com
Java类的组织形式
JDK——>包——>接口、类、异常（类里有字段、构造器、成员方法）
Shift+crtl+D表示复制当前行并插入到下一行
Shift+crtl+K表示删除当前行
char c1 = 'a';
char c2 = '\t';
char c3 = '钟';
char c4 = 97;
System.out.println(c1);//
System.out.println(c2);//
System.out.println(c3);//
System.out.println(c4);//输出97数字表示的那个字母a
System.out.println((int)c1);输出对应的数字97
站长工具 - 站长之家 //Unicode(字母英文和汉字都占2个字节)编码转换网站(ASCII码共有128个字符，一个字节可以表示256个字符，只用了128个) UTF-8（再次改进unicode,可以使用1-6个字节来代表一个字符）
System.out.println(‘a’+10);输出107
1M=1024KB 1K=1024B 1B(byte)=8bit
2.3基本类型转换
自动类型住转换（可以低转高）
注意事项
1.
Int num=’a’;
Double d1 = 80;//int型80可以转换成double
public class Hello{
public static void main(String[] args){
int n1 = 10;
float d1 = n1 + 1.1;//(n1+1.1)会转换成double类型，高赋值给低的不允许，会报错
System.out.println("hello world");
}
}
//当精度大的类型给精度小的时就会报错，精度小的赋值给大的时就会自动进行类型转换
Char->int->long->float->double
Byte->short->int->long->float->double
注意: byte,short和char之间不会相互转换
Byte b1 = 10;//当把一个具体数给byte时，先判断该数是否在byte内，如果可以就行，如左就不会报错
Int n2 = 1;
Byte b2 = n2;//如果赋值是一个变量，错误
Char c1 = b1;//错误，byte不能赋值给char
细节
1.Byte,short和char进行运算时，（只要有byte,即使两个运算也会转为int）会自动转换为int型//byte b3 = b1 + b2; 错误,b1+b2结果为int型
2.多种类型进行运算时，会自动转换为精度大的类型
3.boolean不参与转换
强制转换
Int i = (int)1.9;//1.9会变成1
Int j = 1000;
Byte b1 = (byte)j;//会有精度损失
基本数据类型和字符串类型之间的转换
//基本数据类型转String
Int n1 = 100;
Float n2 =1.1F;
String str1 = n1 + “”;
String str2 = n2 + “”;
System.out.println(n1 + “”+ n2);
String->对应的基本数据类型
String s5 = “123”;
Int num1 = Integer.parseInt(s5);//字符串转换为Int
Double num2 = Integer.parseDouble(s5);// 字符串转换为double
Boolean num3 = Boolean.parseBoolean(“true”);//输出num3为true
//得到s5字符串的第一个字符‘1‘
System.out.println(s5.charAt(0));//编码从0开始，第一个为0
当我们转换时可以把字符串“123“转成一个整数，但是不能把”hello“转化成一个数
演示字符串转基本数据类型
String str = “123”;//如果”hello”,编译运行后就会出错
Int n1 = Integer.parseInt(str);
System.out.println(n1);
{
Char c1 = ‘男’；
Char c2 = ‘女’;
System.out.println(c1+c2); }//输出两个码值相加，不会输出汉字
-
第三章运算符
3.1取模的本质
System.out.println(-10 % 3);//-1
//取模的本质：a % b <=> a - a / b * b
//-10.5 % 3=-10.5-(-10)/ 3 * 3 = -1.5 ，当a为小数时，公式= a - (int)a / b * b
//注意：有小数参与的计算，得到的是一个近似值
System.out.println(10 % -3);//1
System.out.println(-10 % -3);//-1
作为独立使用：i++与++i,都是一样的
3.2关系运算符
Instanceof:检查是否是类的对象，后面会讲
Int a = 10;
Int b = 9;
Boolean flag = a>b;//flag输出true
3.3逻辑运算符
| & | 逻辑与（前面为假时，后面还是会执行） |
| | | 逻辑或（前面为假时，后面还是会执行） |
| && | 短路与（当前面为假时，后面不会再执行）开发中用得更多，效率更高 |
| || | 短路或（当前面为假时，后面不会再执行）开发中用得更多，效率高 |
| ^ | 异或（当两边结果不同时，返回真，否则为假） |
| ！ | 取反（真变假，假变真） |
区别
Int a = 4;
Int b = 10;
If(a < 1 && ++b > 10){//当前面为假时，后面不会再执行
System.out.println(“a” + a + “b”) }
If(a < 1 & ++b > 10){//前面为假时，后面还是会执行
System.out.println(“a” + a + “b”); }//4 10
-
- 赋值运算符
=,+=，a += b ó a = a + b;（其他类推）
赋值运算符运算顺序从右往左，左边只能是变量，右边可以是变量，表达式，常量
Byte b = 3;
b+= 2；//b = (byte)(b+2),底层有一个类型转换
b++ ;// b = (byte)(b+1)
-
- 三元运算符
Int a = 10 ;
Int b = 99 ;
Int result = a > b ? a++ : b-- ;//真返回 a(表达式2不会执行),假返回b
System.out.println(result);//返回99而不是98
使用细节: 表达式1和表达式2需要为可以赋给接收变量的类型（或自动转换），即result的类型不能低于a,b
运用三元运算符输出三个数中的最大数
int n1 = 1222;
int n2 = 342;
int n3 = 34;
int max = n1 > n2 ? n1 : n2;
int max2 = max > n3 ? max : n3;
System.out.println("最大的数="+max2);
运算符优先级
1.只有单目运算、赋值运算符是从右向左运算的
| . () {} ; , | |
| / % | |
| + - | |
| << >> >>> 位移 |
不用记，用多了就记住了
-
- 标识符的命名
规则
- java对各种变量、方法和类等命名时使用的字符列为标识符
- 不可以使用关键字，但是可以包含关键字
- 严格区分大小写，长度没有限制
- 在同一个作用域里面不允许重名，不能包含空格，int a b = 300;//会出现错误
- 数字不可以开头，如1ab;//不可以
规范
- 包名：aa.bbb.ccc//由小写字母和.组成
- 类名、接口名：多个单词组成时，每个单词组成首字母都用大写
- 变量名、方法名：第一个单词首字母用小写，第二个单词首字母用大写（驼峰法）
- 常量名：所有字母都大写多个单词连接用_下划线
-
- 键盘输入语句
import java.util.Scanner;//Scanner类在java.util包里，导入扫描器的类
public class Input{
public static void main(String[] args){
//Scanner类，表示简单文本扫描器，在java.util包
//创建Scanner对象，new创建一个对象，体会myScanner就是Scanner类的对象
Scanner myScanner = new Scanner(System.in);//使用了相关类方法
System.out.println("请输入名字");
//等待用户输入
String name = myScanner.next();//接受用户输入字符串
System.out.println("请输入年龄");
int arge = myScanner.nextInt();//接受用户输入int
System.out.println("请输入薪水");
double sal = myScanner.nextDouble();
System.out.println("你的名字"+name + "\t年龄" + arge +"\t你的薪水"+ sal);
}
}
3.8进制转换
//演示四种进制
int n1 = 0b1010;//二进制->10
int n2 = 1010;//十进制->1010
int n3 = 01010;//八进制->520
int n4 = 0X1010;//十六进制->4112
System.out.println("n1="+n1+"\tn2="+n2+"\tn3="+n3+"\tn4="+n4);
位运算
- 正数的原码、反码、补码都一样（三码合一）
- 负数的反码= 它的原码符号位不变，其他位取反（0->1,1->0）
- 负数的补码=它的反码+1
- 0的反码、补码都是0
- Java没有无符号数，换言之，java中的数都是有符号的
- 在计算机运算的时候，都是以补码的方式来运算的
Int a = 1>>2;//算术右移，低位溢出，符号位不变，并用符号位补溢出的高位（本质是1除以2再除以2，1/2/2=0）
Int b = -1>>2；//算术左移，符号位不变，低位补0（等价于1*2*2=4）
>>> 逻辑右移也叫无符号右移，低位溢出，高位补0
左移（15>>2）= 3
~2= -3//~2结果为-3
2的原码00000000 00000000 00000000 00000010
补码 00000000 00000000 00000000 00000010
取反11111111 11111111 11111111 11111101
补码-1 = 11111111 11111111 11111111 11111100
符号位不变，其他位取反得到-3
10000000 00000000 00000000 00000011
2&3=//System.out.println(2&3); 输出
//先得到2的补码=2的原码00000000 00000000 00000000 00000010
2的补码00000000 00000000 00000000 00000010
同理可得 3的补码00000000 00000000 00000000 00000011
运算后2&3的补码00000000 00000000 00000000 00000010（因为运算后的符号为0，所以结果为正数，所以原码=补码，结果为2）
2|3=
| 按位与& | 两位全为1，结果为1 |
| 按位或| | 两位中有一个为1，结果为1 |
| 按位异或^ | 不同为1，否则为0 |
| 按位取反~ | 0变1，1变0 |
本章作业
1. Int I = 66;
System.out.println(++i + i);//输出134
2. String 转成double类型，char转成String类型
String str = “18.8”;
Double d1 = double.parseDouble(str);
Char c1 = ‘韩‘；
String str2 = c1 + “”;
-
第四章 程序控制结构
4.1 顺序控制
从上往下
String str1 = "123";
int b1 = Integer.parseInt(str1);
char c1 = '钟';
String str2 = c1 + "";
System.out.println(c1);//输出钟
System.out.println(b1 + 123);//输出246
4.2 分支控制(if else和switch和case)
单分支
Scanner myScanner = new Scanner(System.in);
System.out.println(“请输入年龄”)；
Int age = myScanner.nextInt();//接受一个int变量赋值给age
If(age > 18){
System.out.println(“成年人，为自己的行为负责”)；
}else{
System.out.println(“程序继续…”)；
}
//双分支只会进入一个入口，前面进去了之后就
不会进入后面的else
If else分支
If(判断…){
执行…}; else if(判断…){
执行…}; else if(判断…){
执行…}; else if(判断…){
…}; else{默认执行
…};
分支结构可以嵌套，注意不要超过三层（否则可读性差）
列题：
import java.util.Scanner;//Scanner类在java.util包里，导入
public class LotTree{
public static void main(String[] args){
//Scanner类，表示简单文本扫描器，在java.util包
//创建Scanner对象，new创建一个对象，体会myScanner就是Scanner类的对象
Scanner myScanner = new Scanner(System.in);//使用了相关类方法
System.out.println("请输入你的分数");
double score = myScanner.nextDouble();
if(score >= 8){
System.out.println("恭喜你，进入决赛，请输入性别");
char genner = myScanner.next().charAt(0);//字符串转为字符
if(genner == '男'){
System.out.println("请进入男子组");
}else if(genner == '女'){
System.out.println("请进入女子组");
}else{
System.out.println("性别输入有误，无法参加比赛");
}
}else{
System.out.println("很遗憾，你被淘汰了，回家吧！");
}
}
}
Switch 分支
Switch(表达式){
Case 常量1：
语句块1
Break;//如果没有break语句，直接执行第二个Case语句2，不会再判断常量2（穿透）
Case 常量2；
语句块2；
Break;
Case 常量3
语句块3；
Break;
…
Default 语句；}
列题：
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入一个字符A~E");
char c1 = myScanner.next().charAt(0);//在java中，只要有值返回，就是一个表达式
switch(c1){
case 'a' ://a的类型应当与c1一致或者是可以相互转换的类型（表达式的数据类型与///常量数据类型一致）
System.out.println("今天星期一，猴子穿新衣");
break;
case 'b' :
case ‘e’ ://允许直接列出两种情况
System.out.println("今天星期二，猴子当小二");
break;
case 'c' :
System.out.println("今天星期三，猴子爬雪山");
break;
default:
System.out.println("你输入的字符不正确，请重新输入");
}
注意：
- 表达式的数据类型与///常量数据类型一致
- Switch（表达式）的返回值必须是：byte/short/int/char/enmu[枚举]/String
- Case子句中的值必须是常量（或常量表达式），不能是变量
- Default子句是可选的，可以没有（当没有匹配到case时，默认输出default）输出
- Break语句用来执行完一个case语句后跳出switch（如果没有遇到break语句，会继续判断下一个case，直到遇到break）
If else 与 switch的比较
1.如果判断的具体数值不多，而且符合byte/short /int /char /enum[枚举]/String这六种类型，建议使用Switch语句
2.其他情况，对结果boolean类型判断，使用if更多
-
- For循环控制
For( 循环变量初始化；循环条件；循环变量迭代 ){
循环操作（可以多条语句）；}
For(i = 20 ; i > 10 ; i--){
System.out.println(“你好，今天可以打篮球吗”);
}
注意：
1.循环表达式返回的是一个boolean值
2.循环初始可以有多条语句，中间用逗号隔开
3.循环变量初始化和循环变量迭代可以写在for语句前面和后面循环操作后，如下
Int I = 1;
For ( ; I < 10 ; ){
System.out.println(“你好，今天下雨了”)
}
System.out.println(“I =” + i);//输出11
死循环
For( ; ; ){ }
-
- While循环
基本语法
Whlie（循环条件）{//判断为真进入循环体->执行->判断是否继续为真->继续执行
循环体；
循环变量迭代；
}
用while循环输出10句话：
I=1;
While（I <= 10）{
System.out.println(“您好，这里是我的战场”)；
I++;
}
注意细节：
- 返回一个boolean型的表达式
- 先执行，再判断
Do… while 循环控制
Do while 是关键字
先执行一次，再执行（至少执行一次）
循环变量初始化；
Do{
循环体；
循环变量迭代；
}while(循环条件)；//为假时，继续返回执行循环体和循环变量迭代
Int i = 1;
Do{
System.out.println(“您好，天天开心”)；
}while(i < 10);//注意有一个分号
Ctrl + cà退出循环
Scanner myScanner = new Scanner(System.in);
Char answer = ‘ ’;
Do{
System.out.println(“您好，还钱吗”)；
Answer = myScanner.next().charAt(0);
System.out.println(“回答时” + answer)；
}while(answer != ‘y’);
-
- 多重循环控制
//输出空心金字塔
int i,j,k;
int a = 1;
for(i = 1 ; i <= 5 ; i++){
for( j = 1; j <= 5-i ; j++){
System.out.print(" ");
}
for( j = 1; j <= 2*i-1 ; j++){
if(j == 1 || j == 2*i-1 || i == 5){//第一个和最后一个输出*，以及最后一行全部输出*
System.out.print("*");
}else{
System.out.print(" ");
}
}
System.out.print("\n");
}
-
- Break-跳出控制语句
int i= 0;
for(; i < 100 ; i++)
if(i == 3){
break;//break语句会跳出for循环，不结束程序
}else{
System.out.print("i=" + i);
}
标签：
Label:
For(int j = 0; j < 4 ; j++){
Label2 ://标签名称可以任意
For(int I = 0; I < 100; i++) {
If(I == 2){//一旦i== 2，跳出内循环，
Break;}
System.out.println(“i=”+ i); }}//输出0 1
- 1 …
4.7 Continue/ return /break
public class Langin01{
public static void main(String[] args){
for(I = 1; I <= 5; i++){
if(I == 3){
System.out.println(“hello 你好！”);
Return;//return语句用在方法时，表示跳出方法，如果使用再main,表示退出程序，go on输出
//break表示退出for循环，go on 会输出
//continue表示退出本次循环，进行下一次循环变量迭代后的循环
}
System.out.println(“好久不见”);
}
System.out.println(go on…”);
}
}
-
- 本章作业
1. 输出a-z字符
int i = 0;
int count = 0;
char c1 = 'a';
for( ; i< 26 ;i++){ //c1 < 'z';c1++
System.out.print(c1+" ");
count++;
c1++;
if(count % 5 == 0){
System.out.println();
}
}
- 输出1- 1/2 + 1/3 - 1/4 + 1/5...1/100的和
int i;
double sum = 0;//注意必须为double型
int fuhao = 1;
for(i = 1; i <= 100; i++){
sum = sum + (1.0/i)*fuhao;//分子必须为小数
fuhao = -fuhao;
}
System.out.println(sum);
- 输入一个三位数，判断是否为水仙花数
// Scanner myScanner = new Scanner(System.in);
// int number = 0;
// int ge,shi,bai;
// System.out.println("请输入一个数，判断是否为水仙花");
// number = myScanner.nextInt();
// bai = number/100;
// shi = number%100/10;
// ge = number%10;
// if(ge*ge*ge + shi*shi*shi + bai*bai*bai == number){
// System.out.println(number + "是水仙花数");
// }else{
// System.out.println(number + "不是水仙花数");
// }
- 输出1~100之中不能被5整除的数
// int count=0;
// for(int i = 0; i<100 ;i++){
// if(i % 5 != 0){
// System.out.print(i + "\t");//输出制表位
// count++;
// }
// if(count % 5 ==0){//每五个就换行
// System.out.println();
// }
// }
- 计算1+（1+2）+(1+2+3)+(1+2+3+4)+...(+100)的和
int sum = 0;
int sum1 = 0;
for(int j = 1; j <= 100 ; j++){//方法二：for(int i = 1; i <=100 ; i++ )
sum1 = sum1 + j;//for(int j = 1; j <= i ;j++)
sum = sum + sum1;//sum += j ;
}
System.out.println(sum);//运算结果等于171700
- 第五章 数组、排序和查找
- 数组入门(一组同一类型的数据)
记录6只鸡的体重
//记录6只鸡的体重
//形式：double[ ] name或者 double name[ ]
// 定义方法1：double score[] = new double[6];
// 定义方式2：double score[];
//Score = new double[5];
double totalweight= 0;
double[] wight={6 ,2, 5, 7.8 ,4.5 ,4};//定义一个数组
//遍历数组得到数组的所有元素的和，使用for
for(int i = 0; i < 6 ; i++){
System.out.println("第" + (i+1) +"个元素的值=" + wight[i]);
totalweight += wight[i];
}
System.out.println("总体重=" + totalweight+"\n"+ "平均体重="+ totalweight/6);
}
a
A[1] a[ 2] a[2] a[ 3]…
类型要匹配
1.String arr[ ] = {“郑霖”，“米楠”，“mia”};
2.默认存放,定义数组之后，如果没有存放数值，则默认存放如下：
//int 0/ short 0 / byte 0 /float 0.0 /double 0 /Boolean false / String null
3.数组存放从0开始，定义后使用应为arr[i-1]
数组应用
使用数组输出A-Z
char chars[] = new char[26];
for(int i = 0;i < chars.length ; i++){//循环26次.length表示数组的长度
chars[i] = (char)('A' + i);//'A'+i是int型，需要转换
}
-
- 数组赋值机制
基本数据类型赋值，相互不影响如：
int n1 = 2;
int n2 = n1;
n2 = 3; //n1仍然是2
但是在数组赋值时，赋值的是地址(引用传递)：
//int[ ] arr1 = {1,2,3};
Int[ ] arr2 = arr1;//arr1的地址也会指向arr2的地址，arr1本身的地址会被JVM销毁，但是此时arr1/arr2指向的是同一个空间
Arr2[0] = 10;//arr2也能访问到arr1的空间，所以都会改变
For(int i= 0; I <3 ; i++){
System.out.println(arr1[i]);//此时arr1[0]会变成10
}
拷贝到一个独立的数据空间（相互不影响）
int[] arr1 = {1,2,3};
//创建一个新的数组arr2，开辟独立的数据空间
int[] arr2 = new int[arr1.length];//开辟了一个新的空间
for(int i = 0; i < arr1.length ; i++){
arr2[i] = arr1[i];
}
arr2[0] = 100;
System.out.println(arr1[0]);//此时输出的是1
数组翻转
Int [ ] arr = { 11,22,33,44,55,66};
11,22,33,44,55,66
66,22,33,44,55,11//交换1次
66,55,33,44,22,11//交换2次
66,55,44,33,22,11//交换3次
//1.交换次数 = arr.length / 2
//2.每次交换时，对应 下标时arr[ I ] 和arr[arr.length – 1 -I ]
数组扩容（添加元素）
//给数组添加元素
//定义有一个新数组，长度为arr1.length + 1
//遍历arr1数组的元素给新数组，
//将99（需要的添加元素）赋值给新数组
//让arr1指向新数组
int arr1[] = {11,22,33,44,55,66};
int arr2[] = new int[arr1.length + 1];
for(int i = 0 ; i < 6 ; i++){
arr2[i] = arr1[i];
}
arr2[arr2.length-1] = 99;
arr1 = arr2;
for(int i = 0; i < arr1.length ; i++){
System.out.print(arr1[i] + "\t");//此时输出7个数，包含99
}
动态赋值
int arr1[] = {11,22,33,44,55,66};
do{
int arr2[] = new int[arr1.length + 1];
for(int i = 0 ; i < arr1.length ; i++){
arr2[i] = arr1[i];//遍历赋值给arr2
}
System.out.println("请输入你要添加的数");
int addnum = myScanner.nextInt();
arr2[arr2.length-1] = addnum;
arr1 = arr2;
for(int i = 0; i < arr1.length ; i++){
System.out.print(arr1[i] + "\t");//此时输出7个数，包含99
}
System.out.println("请问你要继续添加吗y/n");
char answer = myScanner.next().charAt(0);
if(answer == 'n'){
break;
}
}while(true);
System.out.println("你退出了添加");
-
- 冒泡算法
public class MaoPao{
public static void main(String[] args){
int arr1[] = {11,109,33,2,18,53,7};
//11,33,2,55,66,109
//11,2,33,55,66,109
//2,11,33,55,66,109;需要n-1次比较
int arrlen = arr1.length;
int m,j;
int temp;
for(m=0;m<arrlen-1;m++)
{//一共4次
for(j=0;j<arrlen-1-m;j++)//循环层数
{
if(arr1[j] > arr1[j+1])
{
temp=arr1[j];
arr1[j]=arr1[j+1];
arr1[j+1]=temp;
}
}
System.out.println("第" + (m+1) +"轮排序后如下：");
for(int k = 0; k < arr1.length; k++){
System.out.print("\t" + arr1[k]);
}
System.out.println();
}
System.out.println("最终排序后如下：");
for(int k = 0; k < arr1.length; k++){
System.out.print("\t" + arr1[k]);
}
}
}
-
- 二维数组
int arr1[][] = new int[4][6];
arr1[1][2] = 1;
arr1[2][1] = 2;
arr1[2][3] = 3;
int i,j;
int count = 0;
for(i = 0 ; i < arr1.length ;i++){//遍历二维数组的每个 元素
for(j = 0 ; j < arr1[i].length ;j++){//表示每个一维数字中的所有元素
System.out.print(arr1[i][j]+ "\t");
count++;
if(count % 6 == 0){
System.out.println();
}
}
}
//注意每个二维数组的一维数组之中都存放着一个不一样的地址，这个地址存放的才是数据
二维数组的使用
int arr1[][] = new int[4][];//创建了一个二维数组，但是只确定了一维数组的个数
for(int i = 0 ; i < arr1.length; i++){
arr1[i] = new int[i + 1];//给每个一维数组开空间new，i=0时开（i+1）的空间
//如果没有给一维数组开空间，那么arr[i]就是null
for(int j = 0 ;j < arr1[i].length ; j++){//给一维数组的元素赋值
arr1[i][j] = i + 1;//赋值
}
}
for( int i = 0; i < arr1.length ;i++){
for(int j = 0 ;j < arr1[i].length ;j++){
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
二维数组的使用2
静态初始化
定义
int arr[][] = {{1,1,1},{2,2,2},{100}};//第三个一位数组只有一个元素
打印一个杨辉三角形
int arr1[][] = new int[10][];//创建了一个二维数组，但是只确定了一维数组的个数
for(int i = 0 ; i < arr1.length; i++){
arr1[i] = new int[i + 1];//给每个一维数组开空间new
//如果没有给一维数组开空间，那么arr[i]就是null
for(int j = 0 ;j < arr1[i].length ; j++){//给一维数组的元素赋值
if(j == 0 || j == i){
arr1[i][j] = 1;
}else{
arr1[i][j] = arr1[i-1][j-1] + arr1[i-1][j];
}
}
}
for( int i = 0; i < arr1.length ;i++){
for(int j = 0 ;j < arr1[i].length ;j++){
System.out.print(arr1[i][j] + " ");
}
System.out.println();
}
二维数组使用注意
1.int[ ][ ] y 或 int[ ] y[ ] 或 int y[ ][ ] 三种形式
2.二维数组实际上是多一个一维数组组成的，各个一维数组长度可以不一样
如：int a[ ] [ ] = { {1,2}, {1,2,3} };
课堂练习
X为int 型一维数组，Y为int 型二维数组
Y[0] = x ; //正确的，y[0]为一维数组
Y[0][0] = x[0] ;
-
- 本章作业
1.使用Math.random()
int arr[] = new int[10];
for(int i = 0; i < arr.length ; i++){
arr[i] = (int)(Math.random()*100) + 1;//随机生成0.0~1.0之间的
//数
}
System.out.println("元素情况如下：");
for(int i = 0; i < arr.length ; i++){
System.out.println(arr[i] + "\t");
}
| 栈 二维数组arr1内存形式 Arr1[ ][ ] [0x1122] | 堆[0x1122] Arr[0] [0x1234] arr1[0][0] [0x1234] Arr[1] [0x1235] 0 0 |
| 方法 |
- 写冒泡算法
-
第六章 面向对象的编程
6.1类与对象
//两只猫，一只叫小白，3岁，白色，一只小花，10岁，花色
//单独变量来解决=>不利于数据的管理
String cat1Name = "小白";
int cat1age = 3;
String cat1color = "白色";
//数组=> 数据类型体现不出来，只能通过下标获取信息，名字和变量对应关系不明确
Stirng arr[] = {"小白","3","白色"};
//引入类与对象的原因 现有技术不能完美解决相关问题
对象：【属性】【行为】
把猫的所有属性提取出来=>用户自定义数据类型：猫类（name,age, color, 行为）
Int: java 提供数据的类型
通过类—>猫对象（创建具体一只猫）
类和对象创建形式
Cat cat1 = new Cat();//创建的猫类cat1,cat1为一个对象
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
//创建第二只猫
cat2.name = "小花";
cat2.age = 12;
cat2.color = "花色";
//怎么访问对象的信息呢
System.out.println("第一只猫信息" + cat1.name + " "
+ cat1.age + " " + cat1.color);
System.out.println("第二只猫信息" + cat2.name + " "
+ cat2.age + " " + cat2.color);
}
}
class Cat{
String name;
int age;
String color;
}
JVM的对象内存
| 栈 Cat—> [0x0022] 字符串都会有一个存放地址 | 堆 [0x0022] cat [0x1122] 12//基本数据类型直接存放 [0x1133]
|
|
方法区 常量池 小白[0x1122] 白色[0x1133] |
1. 属性 ó 成员变量 ó field(字段)
2. 属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型（对象、数组）
创建对象的形式
- 先声明再创建
Cat cat;
Cat = new Cat();
- 直接创建
Cat cat = new Cat();
访问属性
Cat.name;
Cat.age;
类与对象的分配机制（重要）
Person p1 = new Person();
P1.age = 10;
P1.name = “小明“；
Person p2 = p1;//引用传递
//指向同一个空间
System.out.println(p2.age);
类与对象分配机制
- 栈：一般存放基本数据（局部变量）
- 堆：存放对象（cat数组等）
- 方法区：常量池（常量，比如字符串），类加载信息
Person p = new person();
p.name = “小明”；
p.age = 23;
1.先加载person类信息(属性和方法信息，只加载一次)
2.再堆中分配空间，进行默认初始化
3.把地址赋给p，P指向对象
4.进行指定初始化à p.name = “jack” p.age = 23
6.2成员方法（人除了有一些属性外还有行为）method
cat1.speak();//调用方法
}
}
class Cat{
String name;
int age;
String color;
//public表示方法是公开的
//void:表示没有返回值
//speak是方法名()形参列表
public void speak(){
System.out.println("我是一只好猫");
}
}
方法调用机制图
Cat cat1 = new Cat();
//计算两个数的和
//表示返回一个int 型 的值
cat1.speak(10,20);
//返回一个值
int getsum = cat1.speak(10,20);
//用getsum来接收10+20
public int speak(int num1,int num2){
int res = num1 + num2;
return res;
}
小结：当程序执行到方法时就会开辟一个独立的空间（栈空间）
当方法执行完毕后，有return语句就会返回
返回到调用方法的地方，继续执行后面的代码
使用注意细节
1.一个方法最多（需要没有void）有一个返回值，但是返回类型可以是一个数组（包括基本类型和引用类型）
AA a = new AA();
Int res1[ ] = a.geteum(1,4);
class AA{
public int[] getsum(int n1,int n2){
int[] resArr =new int[2];
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
}
2.如果方法有要求返回数据类型，则方法体中最后的执行语句必须为return值：返回类型必须与return的值的类型一致或者兼容
3.实际工作中方法名需要有一定的含义
形参列表使用细节
- 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开
- 参数类型可以为基本类型，也可以为引用类型比如prit(int[ ] map)
- 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容的参数
- 方法定义时的参数称为形式参数，简称形参，方法调用时的参数称为实际参数，简称实参，形参跟实参类型、顺序、个数都必须一致
同一个类中的方法可以直接调用（一个类中可以有多个方法）
不同的类中的方法，调用需要先//创建B对象，再调用方法
B b = new B();
b.方法();
//形式如下：
AA a = new AA();
int res1[] = a.geteum(1,4);
System.out.print(a);
class AA{//类
public int[] getsum(int n1,int n2){//类中的方法
int[] resArr =new int[2];
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
public void m1(int x){
int sum = 0;
for(int i = 0 ; i < x ; i++){
sum += sum;
}
System.out.println("总计：" +sum);
}
}
成员方法传参机制
public class Ways01{
public static void main(String[] args){
int a = 10;
int b = 20;
Aa obj = new Aa();
obj.swap(a,b);
System.out.println("a=" + a + "b=" + b);
}
}
class Aa{
public void swap(int a,int b){
System.out.println("a=" + a + "b=" + b);
int temp = a;
a = b;
b = temp;
System.out.println("交换后a=" + a +"交换后b=" + b);
}
}
//基本数据类型，传递的是值，形参的任何改变不影响实参
//调用了方法会产生新的栈，引用类型不是值拷贝，传引用数据的时候->传递的是一个地址（如果是数组的话，可以通过形参来修改实参）
//public class和 class Aa中的变量名称可以相同，因为是相互独立的
//传对象的时候->传递的是一个地址
B b = new B();
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test100(p);
System.out.println(p.age);
}
}
class Person{
String name;
int age;
}
class B{
public void test100(Person p){//传对象
p.age = 200;//p = null ,这样不会影响p.age = 10;
}
}
-
- 递归
递归：方法自己调用自己
重要规则
1.当执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
2.方法的局部变量是独立的，不会相互影响，如N变量
3.如果方法中使用的是引用类型变量（比如数组，对象），就会共享该引用类型的数据
4.递归必须向退出递归的条件逼近，否则会无限递归
5.当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁的规则同时当方法执行完毕或者返回时，该方法也就执行完毕了
-
- 方法重载
同一个方法，但是形参不一样
public class ChognZai{
public static void main(String[] args){
Sum he = new Sum();
System.out.println(he.calculate(1.0,3.2));
}
}
class Sum{
public int calculate(int n1, int n2){
return n1 + n2;
}
public double calculate(int n1, double n2){
return n1 + n2;
}
public double calculate(double n1, double n2){
return n1 + n2;
}
}//同一个类可以设置多个方法，类型或者形参数量不一样就可以
方法重载注意事项
- 方法名一定要一样
- 形参列表（个数/类型/顺序）必须有不同，假如只是参数名字不一样时不行的
- 仅仅是返回类型（空和有）不一样，不会构成方法重载
数组的使用和算法
类的加载过程、接口、异常处理
代码封装：自实现工具封装与打包
IO流与网络通信三要素
泛型、lambda表达式、方法引用、Stream API的使用
SOL分类&基本语法
SELECT语法结构和重点使用
UPDATE语法结构和重点使用
DDL操作、TCL操作（COMMIT\ROLLBACK）
MySQL事务和隔离级别
数据库连接池
Public class Hello{
Public static void main(String[ ] args){
System.out.printIn(“hello world”);
}
}
7971
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
