1.JAVA执行流程
2.注意事项
(1).一个Java文件中只能有一个public类，其它类可以有很多
(2).文件的名字要和public类的名字一致
3.转义字符
\t 制表位，实现文字横排对齐功能
\n 换行，光标走到下一行
\r 回车，光标回到上一行
\\ 一个\
\' 一个单引号
\'' 一个双引号
4.数据类型
点5整型，点 6浮点型，点7字符型，点8布尔型，点15数组
5.整型
(1).各种整数类型都有固定的范围和字段长度
| 类型 | 占用存储空间 |
| byte[字节]基本存储单元 | 1字节 |
| short[短整型] | 2字节 |
| int[整型] | 4字节 |
| long[长整型] | 8字节 |
1Byte=8bit(1字节=8比特）bit是最小存储单位
(2).java的整型常量默认为int型，声明为long型常量需要在数值后面加‘l’或‘L’，数值前加long
public class a {
public static void main(String[] args) {
int num1 = 10;
// int num2 = 20L;
// 错误，num2是int类型，20是长整型，把长整型赋给整型长度减小
long num2 = 20l;
}
}6.浮点型
(1).类型
| 类型 | 占用存储空间 |
| 单精度float | 4字节 |
| 双精度double | 8字节 |
浮点数在机器中的存放形式，浮点数=符号位+指数位+尾数位
(2).java中的浮点型常量默认为double类型，如果想声明为float型，后面必须加‘f’或‘F’
public class a {
public static void main(String[] args) {
float num1=2.1f;
double num2=2.1;
double num3=8.1/3;
// 因为8.1在存储的时候的问题，所以得到的结果不是2.7，是一个接近2.7的小数
}
}
7.字符型
(1).类型
| 类型 | 占用存储空间 |
| 字符型char | 2字节 |
(2).字符常量是用单引号括起来
char c1='a';//输出a
char c2='蔡';//输出蔡
char c3=65;//输出a
char c4='1';//输出1char=65，输出为对应的unicode码A
(3).转义字符
char c4='\t';
//'\t'是一个字符，换行符(4).char本质是unicode码
char c5=97;
System.out.println(c5);//输出a
char c6='a';
System.out.println((int)c6);//输出97(5).char类型可以进行运算，相当于一个整数
char c7='a'+1;
System.out.println(c7);//输出b
System.out.println((int)c7);//输出988.布尔类型
| 类型 | 占用存储空间 |
| 布尔型boolean(true false) | 1字节 |
9.自动类型转换
精度小的类型会自动转换为精度大的数据类型
| 类型 | 占用存储空间 |
| byte | 1字节 |
| char | 2字节 |
| short | 2字节 |
| int | 4字节 |
| long | 8字节 |
| float | 4字节 |
| double | 8字节 |
自动转换规则：
char--->int--->long--->float--->double
byte--->short--->int--->long--->float--->double
char不能自动转换为byte或short
自动转换细节：
(1).有多种类型的数据混合运算时，系统首先自动将所有数据转为容量最大的那种类型再计算
int n1=10;
//float n2=n1+1.1;
//错误，1.1默认为double类型，n1转为double类型，结果应为double类型
double n2=n1+1.1;
//正确(2).char不能自动转换为byte类型或short类型
(3).boolean不参与转换
byte =10;//对，byte范围为-128 - 127
int n3=100;
byte b2=n2;
//错，n2已经为int类型了强制类型转换：
把一些（不必要占用空间的数字）转为（小精度的类型）
使用：(int) 函数，(float)函数，(char)函数
但是可能造成数据缺失和溢出
int num1=(int)1.1;
//精度缺失，num1=1
byte num3=(byte)1000;
//精度溢出byte范围时 -127到128强制转换细节：
(1).char类型可以保存int常量值，但不能保存int变量值，需要强转
char nn1=10;
int nn2=100;
char nn3=nn2;//错误
char nn3=char(nn2);//正确(2).强制转换只对最近的操作数有效
int w1=(int)1.1 * 2 + 2.2 * 3;//错，(int)只对1.1生效
int w2=(int)( 1.1 * 2 + 2.2 * 3);
(3).byte和short类型在进行运算时，当作int类型处理
byte a=16;
short b=14;
short t=a+b;//错误
//a+b被当作int类型处理 ，t是short型
//int不能转为short10.String类型转基本类型，基本类型转String
(1).基本类型转String
在基本类型后加+""
int n1=100;
long n2=100;
float num1=1.1f;
double n3=3.4;
String s1=n1+"";
String s2=n2+"";
String s3=num1+"";
String s4=n3+"";
System.out.println(s1+" "+s2+" "+s3+" "+s4+"");
String转基本类型
通过调用基本类型的包装类调用parsexx方法
String s1="12";
int n1=Integer.parseInt(s1);
float n2=Float.parseFloat(s1);
long n3=Long.parseLong(s1);
byte n4=Byte.parseByte(s1);
boolean n5=Boolean.parseBoolean(s1);注意
把string类型转为基本类型时，数据是要有效的，比如"hello"不能转为int
11.运算符
算术运算符、关系运算符、逻辑运算符
算术运算符
(1).加减乘除
注意除法
System.out.println(10/4);//2
//两个整数相除结果只保留整数部分
System.out.println(10/4.0);//2.5
//10是int4字节，4.0是double8字节，转为double，结果为2.5
double a=10/4;
//10/4为2，2存储为double为2.0
System.out.println(a);//2.0(2).++自增(前置自增，后置自增）
本质上是 i=i+1,只有赋值的时候不一样
前置自增：++i
先自增后赋值；k=++i 等价于 i=i+1,k=i
后置自增：i++
先赋值后自增; k=i++ 等价于 k=i,i=i+1
int i=2;
int k=i++;//k=i,i=i+1
System.out.println("k="+k+" i="+i);
//k=2 i=3
int g=++i;//i=3,i=i+1,g=i
System.out.println("g="+g+" i="+i);
//g=4 i=4int i=66;
System.out.println(++i+i);//134
//(++i)+i-->i=i+1 i+i-->67+67
// 67 67
(3). %(取余）
当a是整数时， a%b=a-a/b*b
当a是小数时，a%b=a-(int)a/b*b
小数参与运算时得到一个近似值
//a%b=a-a/b*b
System.out.println(10%3);//1
System.out.println(10%-3);//1
System.out.println(-10%3);//-1
System.out.println(-10%-3);//-1(4).例题
package char类型;
public class c {
public static void main(String[] args) {
int i=1;//temp=i=1
i=i++;//先赋值后自增 temp=i;i=i+1;i=temp
System.out.println(i);
}
}
问输出i为多少？
答：i=1，因为执行到i=i++时会产生一个临时变量temp来代替i，i=i++可以拆分为temp=i,i=i+1,i=temp;即先把i的值赋给temp，i再自加，再把temp的值赋给i
package char类型;
public class c {
public static void main(String[] args) {
int i=1;
i=++i;//先自增后赋值 i=i+1;temp=i;i=temp
System.out.println(i);
}
}输出i为多少？i=2
package char类型;
public class c {
public static void main(String[] args) {
int i1=10;
int i2=20;
int i=i1++;
System.out.println(i);
System.out.println(i2);
i=--i2;
System.out.println(i);
System.out.println(i2);
}
}输出10 20 19 19
关系运算符
| 运算符 | ||
| == | 相等 | 1==2 false |
| ！= | 不等于 | 1！=2 true |
| < | 小于 | 1<2 true |
| > | 大于 | 1>2 false |
| <= | 小于等于 | 1<=2 true |
| >= | 大于等于 | 1>=2 false |
| instanceof | 测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。 | o instanceof Vector |
逻辑运算符
取反：~连同符号位一起取反
短路： &&与 ||或 ！非
逻辑： &与 |或 ^ 异或
短路运算符：只要是第一个条件不成立为false，就不会再去判断第二个条件
逻辑运算符：要对左右两个条件都判断
例
System.out.println(2&3);//2
//2->00000000 00000000 00000000 00000010
//3->00000000 00000000 00000000 00000011
//&运算
// 00000000 00000000 00000000 00000010得到的是补码
//原码2
System.out.println(~-2);//1
//原码 10000000 00000000 00000000 00000010
//反码 11111111 11111111 11111111 11111101
//补码 11111111 11111111 11111111 11111110
//取反 00000000 00000000 00000000 00000001复合赋值运算符
+= -= /= %= *=
a+=b等价于a=a+b
其它一样
复合赋值运算符细节
(1).运算顺序是从右往左
(2).复合赋值运算符底层会进行类型转换
byte b=1;
b+=1;//底层会发生类型强制转换b+1转为byte类型
b++;//也发生类型强制转换
//b=b+1;错误b+1是int类型，不能赋给byte类型三元运算符
条件表达式？结果1：结果2；
例如 int n=1>2?1:2;
表达式为真，返回结果1
表达式为假，返回结果2
int n1=1;
int n2=20;
int n3=10;
//求三个数中的最大值
int n=n1>n2 ? n1:n2;
int n4=n>n3 ? n:n3;移位运算符
(1).算术左移<<
m<<n 代表把数字m在无溢出的前提下乘以2的n次方。
符号位不变，低位补0
(2).算术右移>>
m>>n 代表把数字m除以2的n次方，取整。
符号位不变，用符号位补溢出的高位
(3).无符号右移>>>
低位溢出，高位补0
(4).没有<<<
例：
System.out.println(1<<3);//1*2的3次=8
System.out.println(19>>3);//2
System.out.println(21>>3);//(21-1)/8=2···4 取2
运算符优先级(高到低)
只有单目运算符和赋值运算符是从右往左运算的
赋值运算符包括= *= /= %= += -= <<= >>= >>>= &= ^= |=
12.标识符
(1).不能以数字开头，不能有空格
(2).包名：多单词组成时所有字母小写,aabbcc
(3).类名、接口名:多单词组成时所有单词首字母大写，AaBbCc(大驼峰)
(4).变量名、方法名：多单词组成时，第一个单词的首字母小写，第二个单词开始每个单词首字母大写，aaBbCc
(5).常量名：所有字母都大写，多单词时使用下划线连接，AA_BB_CC
13.键盘输入语句
步骤：(1).导包,import java.util.Scanner
(2).创建该类对象 Scanner s=new Scanner(Sysem.in)
（3).调用对象和函数 s.nextInt() nextFloat() 、nextDouble()等方法
import java.util.Scanner;
public class c {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入姓名");
String name=scanner.next();
System.out.println("年龄");
String age=scanner.next();
}
}
14.顺序控制
(1).if 、if···else 、 if···else嵌套 、 if···else···if···else
if (condition) {
}else if (condition) {
} else {
}(2).switch
switch后跟表达式
case 常量1：表示表达式结果为常量1时执行case1对应的语句
break：表示退出switch
default：如果表达式结果没有常量值匹配，就执行default
Scanner scanner=new Scanner(System.in);
System.out.println("请输入成绩");
int fs=scanner.nextInt();
switch (fs/10) {
case 9:
System.out.println("成绩优秀");
break;
case 8:
System.out.println("成绩良好");
break;
case 7:
System.out.println("成绩一般");
break;
case 6:
System.out.println("成绩及格");
break;
default:
System.out.println("成绩不及格");
break;
}
}
(3).for
外循环控制行，内循环控制列
例1：
统计3个班的平均分和所有班级的平均分，每个班5个人，学生成绩从键盘输入
int sum=0;
int pj=0;
int ssum=0;
Scanner scanner=new Scanner(System.in);
for (int i = 1; i <= 3; i++) {
System.out.println(i+"班成绩");
for (int j = 1; j <= 5; j++) {
int n=scanner.nextInt();
sum=sum+n;
pj=sum/5;
}
ssum=ssum+sum;//三个班的所有人成绩
System.out.println(i+"班平均成绩："+pj);
pj=0;
sum=0;
}
System.out.println("三个班平均成绩："+ssum/15);例2：
统计三个班及格人数，每个班5人
int sum=0;//及格人数
Scanner scanner=new Scanner(System.in);
for (int i = 1; i <= 3; i++) {
System.out.println(i+"班成绩");
for (int j = 1; j <= 5; j++) {
int n=scanner.nextInt();
if (n>=60) {
sum=sum+1;
}
}
}
System.out.println("三个班及格人数："+sum);例3：
打印99乘法表
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j+"*"+i+"="+i*j+" ");
}
System.out.println();
}
}例4：
打印下列图案
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}for (int i = 1; i <= 6; i++) {
for (int x = 1; x <= 6-i; x++) {
System.out.print(" ");
}
for (int j = 1; j <= 2*i-1; j++) {
System.out.print("*");
}
System.out.println();
}自己的代码：写的稀碎(下面有老师的 )
for (int i = 0; i <= 3; i++) {
for (int j = 0; j <= 2-i; j++) {
System.out.print(" ");
}
for (int j = 0; j < 1; j++) {
System.out.print("*");
}
if (i==1) {
for (int j = 4; j <=4 ; j++) {
System.out.print(" ");
}
for (int j = 5; j <=5; j++) {
System.out.print("*");
}
}
if (i==2) {
for (int j = 3; j <=5 ; j++) {
System.out.print(" ");
}
for (int j = 6; j <=6; j++) {
System.out.print("*");
}
}
if (i==3) {
for (int j = 2; j <=7; j++) {
System.out.print("*");
}
}
System.out.println();
}
}老师的代码：
public class a {
public static void main(String[] arge) {
int num=5;
for (int i = 1; i <= num; i++) {
//打印空格
for (int j = 1; j <=num-i; j++) {
System.out.print(" ");
}
for (int j = 1; j <=2*i-1; j++) {
//如果是当前行的第一个位置或最后一个位置或最后一行，就打印*
if (j==1 | j==2*i-1 |i==num) {
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println();
}
}
}
(4).while
执行流程：
注意：循环条件是返回一个bool值
例1：
打印1-100之间能被3整除的数
int n=1;
while(n<100) {
if(n%3==0) {
System.out.println(n+" ");
}
n++;
}
例2：
打印40-200之间能被4整除的数
int n=40;
while(n<200) {
if(n%4==0) {
System.out.println(n);
}
n++;
}(5).do···while
执行流程：
例1：
打印1-100
int n=1;
do {
System.out.println(n);
n++;
} while (n<=100);例2：
计算1-100的和
int n=1;
int sum=0;
do {
sum=n+sum;
n++;
} while (n<=100);
System.out.println(sum);例3：
统计1-200之间能被5整除但不能被3整除的个数
int n=1;
do {
if(n%5==0 && n%3!=0) {
System.out.println(n);
}
n++;
} while (n<=200);
例4:
如果输入的是y，停止输出"qwq";如果输入的是n，一直输出"qwq".
Scanner scanner=new Scanner(System.in);
System.out.println("输入y/n:");
char c1='y';
String s1=scanner.next();
char c2=s1.charAt(0);
do {
System.out.println("qwq");
} while (c2!=c1);(6).break和continue
相同点:(1).都是用来控制循环结构的，停止循环
不同点：(1).break可以在switch语句中使用，continue不可以在switch中使用
(2).break结束循环，continue跳过当前循环，继续执行下面的
例1：
public class a {
public static void main(String[] args) {
double money=100000;
int num=0;
while(money>0) {
if (money>50000) {
money=money-money*0.05;
num=num+1;
} else {
if (money>=1000) {
money=money-1000;
num=num+1;
}else {
break;
}
}
}
System.out.println(num);
}
}
例2：
输出1-100之间的不能被5整除的数，每一行5个
public class a {
public static void main(String[] args) {
int num=0;
for (int i = 1; i <= 100; i++) {
if (i%5!=0) {
num=num+1;
if (num%5==0) {
System.out.println(i+" ");
}else {
System.out.print(i+" ");
}
}
}
}
}
例3：
求出1+(1+2)+(1+2+3)+·······+(1+2+3+·····+1000)的结果
public class a {
public static void main(String[] args) {
int sum=0;
for (int i = 1; i <=100; i++) {
for (int j = 1; j <=i; j++) {
sum=j+sum;
}
}System.out.println(sum);
}
}15.数组
数组是一种引用类型数据，
(1).数组初始化，定义数组
//动态初始化
//(1)数据类型 数组名[]=new 数据类型[大小]
//int a[]=new int[5];或
int []a=new int[5];
//(2)
int b[];//或int[] b
b=new int [5];
//静态初始化
int c[]= {1,2,3,4};
int []d= {1,2,3,4};
//中括号可以放在数组名前或后1. Int a[]=new int[5];
2. int a[]; a=new int[5];
3. int a[]={1,2,3,4,5};
(2).数组赋值
公用一个地址，你改值，它也会改
//基本数据类型赋值是直接赋值
int a=10;
int b=a;
b=20;
System.out.println(a);//10
System.out.println(b);//20
//引用数据类型赋值是地址赋值
//数组是引用数据类型
//会把c数组值的地址赋给d，d修改数据，c的数据也会改变
//c和d的数据存放在一个位置
int c[]= {1,2,3};
int d[]=c;
d[0]=2;
for (int i = 0; i < d.length; i++) {
System.out.print(c[i]+" ");
//2,2,3
}
for (int i = 0; i < c.length; i++) {
System.out.print(d[i]+" ");
//2,2,3
}(3).数组的操作
1).数组拷贝
//这是用一个地址
int c[]= {1,2,3};
int d[]=c;
d[0]=2;
//这是各自的地址，不相互影响
int []a= {1,2,3};
int []b= {a.length};
for (int i = 0; i < b.length; i++) {
b[i]=a[i];
}2).数组翻转
int a[]= {1,2,3,4,5};
int b[]=new int [a.length];
for (int i = 0; i <a.length; i++) {
b[i]=a[a.length-i-1];}
for (int i = 0; i < b.length; i++) {
System.out.print(b[i]+" ");
}3).数组扩容
Scanner scanner=new Scanner(System.in);
int a[]= {1,2,3};
do {
String string=scanner.next();
if (string=="n") {
break;
}
if(string=="y"){
int num=scanner.nextInt();
int b[]=new int [a.length+1];
for (int i = 0; i < a.length; i++) {
b[i]=a[i];
}
b[b.length-1]=num;
a=b;
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
} while (true);4).数组缩减
和上面差不多
5).数组查找
顺序查找:从前往后查找
二分查找：
6).冒泡排序
第一次比较把最大的数放到最后一个。
第二次比较把第二大的数放到倒数第二个。
int a[]= {24,69,80,57,13};
int temp=0;
for (int i = 0; i < a.length-1; i++) {
for (int j = 0; j < a.length-i-1; j++) {
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[i]);
}
例：创建char类型数组，打印26个大写英文字母
char a[]=new char [26];
a[0]='A';
for (int i = 1; i < a.length; i++) {
a[i]=(char) (a[i-1]+1);
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}例：请求数组的最大值{4,-1,9,10,23},并得到下标
int a[]={4,-1,9,10,23};
int max=a[0];
int maxindex=0;
for (int i = 0; i < 5; i++) {
if (max>a[i]) {
max=max;
maxindex=0;
} else {
max=a[i];
maxindex=i;
}
}
System.out.println("最大值："+max);
System.out.println("下标"+maxindex);(4).二维数组
1).二维数组创建
int a[][]
int []a[]
int [][]a
都可以静态：
int [] [] a={{0,0,0,1},{0,0,0,2},{0,0,0,3},{0,0,0,4}};
或 int [] [] a={{0,0,0,1},{0,0,0,2},{0,0,0,3},{0,0,0,4}};
动态：
int a[] []=new int[2][3];//创建一个两行三列的数组int a[][];
a=new int [2][3];
等价于
int a[]=new int [2][3];列数不确定时：
inta[][]=new int[2][];//创建一个两行n列的数组
for(int i=0;i<a.length;i++){
//给每一个一维数组开辟空间
//如果没有给一维数组new，那么a[i]=null
a[i]=new int [i+1];2).二维数组遍历
arr.length表示有几个一维数组
arr[i].length表示一个一维数组有几个元素
package 数组;
public class b {
public static void main(String[] args) {
int a[][]={{0,0,0,1},{0,0,0,2},{0,0,0,3},{0,0,0,4}};
for (int i = 0; i < a.length; i++) {
//a.length有几个一维数组
for (int j = 0; j < a[i].length; j++) {
//每个一维数组的长度
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}3).二维数组的练习
例：杨辉三角
1
11
121
1331
14641
package 数组;
public class b {
public static void main(String[] args) {
int a[][]=new int[10][];
for (int i = 0; i < a.length; i++) {
a[i]=new int[i+1];
for (int j = 0; j < a[i].length; j++) {
if (j==0||i==j) {
a[i][j]=1;
} else {
a[i][j]=a[i-1][j]+a[i-1][j-1];
}
}
}
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
例：
int[] x,y[];//把int[]看作一个整体
// int[] x;//x是一维数组
// int[] y[];//y是二维数组16.类和对象
1.对象和类
package lei;
public class a {
public static void main(String[] args) {
//使用oop（面向对象）实例化一只猫
//创建第一只猫，猫1
Cat m1=new Cat();
m1.name="猫1";
m1.age=10;
m1.color="白色";
//创建第2只猫，猫2
Cat m2=new Cat();
}
}
class Cat{
//属性
String name;
int age;
String color;
//方法
public void eat() {
}
}2.方法调用和返回值问题
(1).如何返回多个值
返回一个数组
package lei;
public class a {
public static void main(String[] args) {
t t1=new t();
int [] sum=t1.getSum(1, 2);
System.out.println(sum[0]);
System.out.println(sum[1]);
}
}
class t{
public int[] getSum (int n1,int n2) {
int []sum= new int[2];
sum[0]=n1+n2;
sum[1]=n1-n2;
return sum;
}
}
(2).返回的值要和方法的类型要求的值一致或兼容
package lei;
public class a {
public static void main(String[] args) {
b a1=new b ();
a1.f1();
}
}
class b{
public double f1(){
double d1=1.1+2.2;
// return d1;正确
int n=1;
// return n;错误n是int类型，f1函数是double类型
}
}
(3).方法返回类型可以是任意类型，包括数组和对象
(4).如果是void类型的方法，则可以没有返回值，或只写return
public void f1(){
System.out.println("你好");
return;
}(5).方法名采用驼峰式命名法
getSun
(6).方法里不能再定义其它方法
(7).传递参数时类型要匹配或兼容
package lei;
public class a {
public static void main(String[] args) {
b a1=new b ();
byte n1=1;
byte n2=2;
a1.f1(n1,n2);
}
}
class b{
public int f1(int a, int b){
return a+b;
}
}
发生自动类型转换byte-->int
如果n1，n2是double类型则不能转换
(8).同一个类中的方法可以直接调用
class b{
public int f1(){
return 1;
}
public int f2() {
int n=f1();
return n;
}(9).跨类调用方法通过对象名调用
如果c类想用b类中的方法
class b{
public int f1(){
return 1;
}
}
class c{
b b1=new b();
int n=b1.f1();
}3.方法传参机制
(1).基本数据类型的实参传递给形参，形参改变，实参不受影响
(2).引用数据类型的实参传递给形参，形参改变，实参也改变
(3).每次调用一个方法都会形成一个新栈
4.递归
自己调用自己
(1).递归规则
执行一个方法时，就创建一个新栈空间。
方法的局部变量是独立的，不会相互影响，每个栈也是独立的。
如果方法中使用的是引用类型数据，就会共享该数据。
当一个方法执行完毕或者遇到return，就会返回，遵守谁调用，就把结果返回给谁。
例：
package lei;
public class A {
public static void main(String[] args) {
b b1=new b();
b.f1(4);
}
}
class b{
public static void f1(int n){
if(n>2) {
f1(n-1);
}
System.out.println("n="+n);
}
}
例：阶乘
package lei;
public class A {
public static void main(String[] args) {
b b1=new b();
System.out.println(b1.f1(5));
}
}
class b{
public int f1(int n){
if (n==1) {
return 1;
} else {
return f1(n-1)*n;
}
}
}例：斐波那契数列
从第三个数起，每一个数都是前两个数之和。
1，1，2，3，5，8，13
package lei;
public class A {
public static void main(String[] args) {
b b1=new b();
System.out.println(b1.f1(8));
return ;
}
}
class b{
public int f1(int n){
if (n==1 || n==2) {
return 1;
} else {
return f1(n-1)+f1(n-2);
}
}
}
例：有一堆桃子，每天吃一半，再多吃一个，第十天只有一个了，请问有多少个桃子
package lei;
public class A {
public static void main(String[] args) {
b b1=new b();
System.out.println(b1.f1(10));
return ;
}
}
class b{
public int f1(int n){
if (n>1) {
return (f1(n-1)+1)*2;
} else {
return 1;
}
}
}
例：汉诺塔问题
例：八皇后问题
17.方法
(1).方法重载
注意：
1.方法名：必须相同
2.参数列表：必须不同(参数类型或个数或参数顺序不同即可)
3.返回类型：可以相同，可以不同
package 方法;
public class qwq {
public static void main(String[] args) {
a a1=new a();
a1.sum(1,2.3);
a1.sum(2.3 ,2);
a1.sum(2.3);
}
}
class a{
// 下面这些都是重载函数
public void sum(int n1,double d1) {
System.out.println(n1+d1);
}
public void sum(double d1,int n1) {
}
public double sum(double d1) {
return d1;
}
public void sum(double d1,double d2,double d3) {
}
}(2).可变参数
注意：
1.名称相同，功能相同，参数个数不同，就可以使用可变参数。
2.int... 表示接受的参数类型是int类型，可接收0个-多个。
3.可以把可变参数本质就是数组，可以通过for循环遍历，也有length。
2.int... 表示接受的参数类型是int类型，可接收0个-多个。
3.可以把可变参数本质就是数组，可以通过for循环遍历，也有length。
4.一个形参列表只能有一个可变参数。
5.可变参数和其他参数在一起，可变参数必须要放到最后
package 方法;
public class qwq {
public static void main(String[] args) {
a a1=new a();
double num=a1.sum(1.1, 2,3,4);
System.out.println(num);
}
}
class a{
public double sum(double d1,int...n1) {
System.out.println(n1.length);//看作数组
double num=0;
for (int i = 0; i < n1.length; i++) {
num=num+n1[i];
}
num = d1+num;
return num;
}
}package 方法;
public class qwq {
public static void main(String[] args) {
a a1=new a();
int arr[]= {2,3,4};
a1.sum(1.1, arr);
}
}
class a{
public void sum(double d1,int...n1) {
}
}(3).作用域
注意：
//1.属性和局部变量可以重名，访问时遵循就近原则
//2.属性也是全局变量
//3.局部变量只能在对应的方法中使用
//4.全局变量(属性)可加修饰符，public private protected
//5.局部变量不可以加修饰符
(4).构造方法
使用：
1.方法名和类名相同
2.没有返回值
3.修饰符可以默认
4.创建对象时由系统自动调用
注意：
1.一个类可以定义多个不同的构造函数
2.构造器是完成对象初始化，不是创建对象
3.如果没有定义构造器，默认生成一个无参的
4.一旦自己定义了构造器，默认构造器就被覆盖了，如果还想使用要显示定义一下
package gouZaoFangFa;
public class a {
}
class person{
String name;
int age;
public person(String name ,int age) {
this.name = name;
this.age = age;
}
person(){//显示定义一下无参构造器
}
}(5).this关键字
注意：
1.this关键字可以访问本类中的属性，方法，构造器。
2.访问构造器 this.(参数);
3.this用来区分当前类的属性和局部变量
4.当前创建的对象是谁，this就指得谁。
5.this只能在类内部使用
18.包
注意：
1.com.qhx.edu.user；//这是一个包名 com.公司名.edu项目名.user模块包
2.java.lang.*//lang包里的所有类
3.java.util.*;//系统提供的工具包scanner
4.java.net.*;//网络包
5.java.awt.*//java的界面开发
19.访问修饰符规则
1.private(私有):只能a类可以访问a类
2.default(默认)：a类，b类在一个包里可以访问，子类不可以访问
3.protected(保护):子类和同一个包中的类可以访问
| 访问级别 | 访问控制符 | 本类 | 本包 | 子类 | 不同包 |
| 公开 | public | ok | ok | ok | ok |
| 受保护 | protected | ok | ok | ok | no |
| 默认 | 没有 | ok | ok | no | no |
| 私有 | private | ok | no | no | no |
20.封装(encap）
1.set给属性赋值，判断值是否合理
2.get得到属性的值
3.给属性加访问修饰符
4.将构造器和xxx方法结合，在构造器里调用setxx()方法
package com.qhx.encap;
public class encap1 {
public static void main(String[] args) {
person person = new person();
//person.name="a";//可以直接给名字赋值
//不能给年龄赋值，年龄是私有化的
person.setName("aaa");
person.setAge(170);
person.setSalary(3000);
System.out.println(person.info());
}
}
class person {
public String name;
private int age;
private double salary;
//自己写set，get太慢使用快捷键ctrl+insert
//名字长度2-6
public void setName(String name) {
if (name.length()>=2 &&name.length()<=6){
this.name = name;
}else {
System.out.println("名字要在2-6");
this.name="无名";
}
}
public String getName() {
return name;
}
public void setAge(int age) {
if(age>=1&&age<=120){
this.age = age;
}else{
System.out.println("年龄要在1-120");
this.age=10;
}
}
public int getAge() {
return age;
}
public void setSalary(double salary) {
this.salary = salary;
}
public double getSalary() {
return salary;
}
//写一个方法，输出信息
public String info() {
return name + age + salary;
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
