第一章:
System.out.println();//ln下一行换行 \n直接换行 \t
程序运行3步骤：
1，编写源程序
2，编译源程序
3，运行
第二章：<<变量>>（内存中的一块存储空间）
8种基本数据类型：
整数
整数类型 byte 1字节(8位)
short 2字节(16位)
int 4字节(32位)
long 8字节(64位)
小数类型 flout 4字节(32位)
bouble 8字节(64位)
布尔类型 boolean ture/false
字符类型 char 2字节（16位）
使用变量的3步骤：
1，声明变量：数据类型 变量名;
2，赋值： 变量名=值;
3, 使用：变量名;
命名规范：
a.赋值运算符：=
b.算术运算符：+ ，-， * ，/；
前++，--（先赋值再运算）;后++，--（先运算再赋值）
c.比较运算符：> ，<， >=， <=， !=， ==；
d.逻辑运算符：&&，||，!；
e.条件运算符（三元运算符）：条件？结果1：结果2；（当条件为真时，得到结果1，否则得出结果2）
f.位运算符：（计算机所有二进制都是用补码进行计算）
0111 1111是二进制最大的数；1111是二进制最小的数。
源码 反码 补码
正数（3）0000 0011 0000 0011（正数与源码相同）[二进制的第一位是符号位] 0000 0011（与反码相同）
负数（-3）1000 0011 1111 1100（除符号位不变，其余位数和源码相反） 1111 1101（在反码基础上加1）
计算：3+（-3）=0
0000 0011
+ 1111 1101
0000 0000
<<:左移，将2进制左移，低位产生空位用0补齐（如何将2用最高效率变成8？答：将2左移2位。(2<<2)==0000 0010--0000 1000）
>>:带符号右移(16<<2:0001 0000--0000 0010)
>>>:无符号右移
***运算符优先级：算术>比较>逻辑>赋值>位运算符
数据类型转换：自转（两种类型相互兼容，目标类型精确度大于源类型）
强转（目标类型精确度小于源类型。)例子：
double d=0.1;
int a=(int）d;
分解获得各个数：
int no=12;
int shiwei=no%10/10;
第三章：<<选择结构2>>
产生0——n随机数的语法：
int random=（int）（Math.random(）*n)+1;
流程图：
if(条件1){
代码块1
}else {
代码块2
}
嵌套if:
if(条件1){
if(条件1){
代码块1
}else {
代码块2
}
}else {
代码块2
}
多重if：
if(条件1){
代码块1
}else if(条件2){
代码块2
}else {
代码块n
}
第四章：<<选择结构2>>
switch后常量值可以是：int short byte char String 枚举等类型。
case后接：int short byte char String 枚举等类型。
switch(常量值){
case 值1:
代码块1
break;
case 值2:
代码块1
break;
case 值3:
代码块1
break;
default:
代码块
break;
}
switch与多重if区别：
switch if
不同 等值判断 区间判断
相同 都用于多重分支条件结构
第五章：<<循环结构>>
循环四要素：
初始值
循环条件：为boolean类型
循环体
迭代变量
while循环（先判断再执行）
while(循环条件){
循环体
迭代变量
}
do-while循环（先执行再判断）
do{
循环体
迭代变量
}while(循环条件);
程序调试：1.分析错误，设置断点
2.启动调试，单步执行
3.观察变量，发现问题
第六章: <<for循环>>
for(初始值;循环条件;迭代变量){
循环体
}
break：结束整个循环
continue：跳出本次循环进入下一次
return：
3种循环语句比较：
while循环：先判断再执行
do-while循环：先执行在判断
for循环：先判断再执行，循环次数确定
第8章:<<数组>>
数组:一组相同数据类型的数据
使用数组4步骤：
1，声明数组：数据类型[] 数组名;
2,分配空间：数组名 = new 数据类型[大小];
数据类型[] 数组名= new 数据类型[大小];
3，赋值：数组名[下标]=值;
4, 使用: 数组名[下标]（数组下标从0开始)
数组排序：Arrays.sort(数组名）；
Arrays.binarySearch:
A.向数组插入元素：
package and;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int no[]=new int [3];
no[0]=9;
no[1]=6;
int index=no.length;
System.out.println("请输入要增加的元素：");
int num=input.nextInt();
//找到数组插入的位置
for (int i = 0; i < no.length; i++) {
if (num>no[i]) {
index=i;
break;
}
}
//输出原数组
System.out.println("原数组元素为：");
for (int j = 0; j < no.length; j++) {
System.out.println(no[j]+"\t");
}
//元素后移
for (int i =no.length-1 ; i < index; i--) {
no[i]=no[i-1];//index下标开始的元素后移
}
no[index]=num;//插入数据
System.out.println("插入成绩的下标为："+index);
System.out.println("插入后的成绩为：");
for (int i = 0; i < no.length; i++) {
System.out.println(no[i]+"\t");
}
}
}
B.删除数组中的元素：
package and;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int no[]=new int [3];
no[0]=9;
no[1]=6;
no[2]=3;
int index=0;
System.out.println("原数组元素为：");
for (int j = 0; j < no.length; j++) {
System.out.println(no[j]+"\t");
}
System.out.println("请输入要删除的元素：");
int del=input.nextInt();
//找到数组删除的位置
for (int i = 0; i < no.length; i++) {
if (del==no[i]) {
index=i;
break;
}
}
System.out.println("删除成绩的下标为："+index);
//输出原数组
//元素后移
for (int i = index; i <no.length-1 ; i++) {
no[i]=no[i+1];//index下标开始的元素后移
}
System.out.println("删除后的成绩为：");
for (int i = 0; i < no.length-1; i++) {
System.out.println(no[i]+"\t");
}
}
}
第九章：<<双重循环>>
for(初始值;循环条件;迭代变量){
for(初始值;循环条件;迭代变量){
循环体
}
}
外层变量变动一次，内存循环执行一遍
打印九九乘法表：
package and;
public class test4 {
public static void main(String[] args) {
int rows=9;
//外层循环控制乘法表行数
for (int i = 1; i <= rows; i++) {
for (int j = 1; j <=i; j++) {
System.out.print(j+"*"+i+"="+j*i+" ");
}
System.out.println();
}
}
}
打印菱形
package and;
import java.util.Scanner;
public class test3 {
public static void main(String[] args) {
package and;
import java.util.Scanner;
public class test3 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入菱形的行数：");
int rows=input.nextInt();
if (rows%2==0) {
System.out.println("请输入奇数：");
rows=input.nextInt();
}else{
//外层循环控制菱形上半部分的行数
for (int i = 0; i <= rows; i++) {
//内层循环控制菱形上半部分每行空格个数
for (int j = 1; j <= rows-i; j++) {
System.out.print(" ");
}
//内层循环控制菱形上半部分每行*个数
for (int j = 1; j <= 2*i-1; j++) {
System.out.print("*");
}
System.out.println();
}
//外层循环控制菱形上半部分的行数
for (int i = 0; i <= rows; i++) {
//内层循环控制菱形上半部分每行空格个数
for (int j = 1; j <=i-1; j++) {
System.out.print(" ");
}
//内层循环控制菱形上半部分每行*个数
for (int j = 1; j <= 2*(rows-1)-2*(i-1); j++) {
System.out.print("*");
}
System.out.println();
}
}
}
}
第十一章：<<类和对象>>
类和对象？
电脑怎么认识这个世界呢？
类：告诉电脑这个世界是什么构成的(分类)
对象：(类别中的具体实体)
面向对象的优点：
1.与人类思维一致
2.信息隐藏
3.提高程序可用性
类和对象的关系：
类是对象的抽象，对象是类实例
访问修饰符（public protected private）
访问修饰符 class 类名{
//属性:特征
//方法:行为或功能
}
方法的调用：
同一类中直接用：方法名（）
不同类中需要创建对象，对象名.方法名（）；
第十二章 <<类的无参方法>>
无参方法：不带条件的行为
访问修饰符 返回值类型 方法名(){
方法体;
}
返回值类型：void(无返回) 所学过的数据类型(有返回，return "返回值")
类型值必须一致；调用有返回值的方法，必须定义一个变量接收这个返回值
方法的调用：对象名.方法名（）；
成员变量和局部变量的区别？
成员变量 局部变量
作用域不同 类 方法
初始值不同 有初始值 无初始值
第十三章：<<带参数的方法>>
有参方法：带条件的行为
访问修饰符 返回值类型 方法名(参数列表){ 形参：形容这个方法的条件是什么
方法体;
}
实参：调用方法时传过去的值
形参和实参：类型一致，个数一致，顺序一致
数组作为参数的方法：（在数组中计算平均值，寻找最大值）
通过创建学生类
package book;
public class Student {
public double Avg(int []scores){
int sum=0;
double avg=0.0;
for(int i=1;i<scores.length;i++){
sum+=scores[i];
}
avg=(double)sum/scores.length;
return avg;
}
public int Max(int[]scores){
int max=scores[0];
for (int i = 1; i < scores.length; i++) {
if (max<scores[i]) {
max=scores[i];
}
}
return max;
}
}
测试类
package book;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
Student s=new Student();
int []scores=new int[5];
System.out.println("请输入5位参赛者的成绩：");
for (int i = 0; i < 5; i++) {
scores[i]=input.nextInt();
}
double avg=s.Avg(scores);
System.out.println("平均成绩为："+avg);
int max=s.Max(scores);
System.out.println("平均成绩为："+max);
}
}
对象作为参数的方法：
package book1;
public class Student {
//形式类
int id;
String name;
int age;
int score;
public void show(){
System.out.println("学号\t姓名\t年龄\t分数");
System.out.println(id+"\t"+name+"\t"+age+"\t"+score);
}
}
//学生管理类
public class StudentBiz {
Student[] s=new Student[30];
public void add (Student st){//增加学生
for (int i = 0; i < s.length; i++) {
if (s[i]==null) {
s[i]=st;
break;
}
}
}
public void show(){//展示学生信息
System.out.println("本班学生列表：");
for (int i = 0; i <s.length; i++) {
if (s[i]!=null) {
s[i].show();
}
}
System.out.println();
}
}
//测试类
public class Test {
public static void main(String[] args) {
Student s1=new Student();
s1.id=1;
s1.name="zry";
s1.age=11;
s1.score=95;
Student s2=new Student();
s2.id=2;
s2.name="ry";
s2.age=11;
s2.score=80;
StudentBiz stu=new StudentBiz();
stu.add(s1);
stu.add(s2);
stu.show();;
}
}
包：1.将类分成较小点单元，易于寻找
2.防止命名冲突
3.允许更广范围内保护类，数据和方法
声明：package 包名
第十五章：<<字符串>>
A.创建字符串对象的3种方式：
1.String s=new String ();
2.String s="hello";
3,String s=new String("hello");
B.字符串的长度:
s.length();
C,字符串的比较：
1.s.equals(s1);
==:判断两个字符串对象在内存中的首地址是否相等，判断11是否是同一个字符串
equals():判断两个字符串内容是否相等；
2.s.equalsIgnoreCase(s1):忽略字符串大小写进行比较；
3.s.toLowerCase().equals(s1).toLowerCase():转换为小写字母并且返回小写字母
4.s.toUpperCase().equals(s1).toUpperCase():转换为大写字母并且返回大写字母
D.复杂字符串的处理：
1.字符串的连接：s.concat,(s1);
2.字符串的提取和查询：
public int indexOf(int s):查询第一个出现的字符s
public int lastIndexOf(int s):查询最后一个出现的字符s
public String substring(int index):提取从index字符开始及之后的字符
public String substring(int beginindex,int endindex):提取从index字符开始到endindex之间的字符
public String trim（）；返回不含空格的字符
E.字符串的拆分：s.split(String separator,int limit);
separator:要拆分的字符
limit:限制返回字符中的元素
F:StringBuffer：String的增强版（不仅可以是字符，还可以是int等类型）
s.toString();将s转换成String类型并输出
s.append(s2):在s的后面追加s1的内容；
s.insert(位置，参数）；将参数插入到s的指定位置并返回；
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
