基础语法
符号
注释符
- 单行注释 : //
- 多行注释 : /* 注释内容 */
- 文档注释: /** 注释内容 * /
标识符
关键字：int for do final static … 50
注意点：
- 所有的标识符仅可以字母，美元符号，下划线等开始！
- 首字符以后的内容可为任意字符！
- 不能使用关键字作为变量名和方法名！
- 标识符区分大小写！
- String不是关键字！
数据类型
注意点：
- java属于强类型语言：要求所有变量要严格符合规定，所有变量都必须先定义后才能使用！
强类型语言的优点为安全性高，缺点为速度慢。弱类型语言则相反！
- long类型的变量值后需加L！
- float类型的变量值后需加F！
- 整数扩展：二进制0b 八进制0 十六进制0x
- 尽量避免进行浮点数比较，可使用BigDecimal(数学工具类)！
- 尽量避免进行浮点数比较，可使用BigDecimal(数学工具类)！
- 尽量避免进行浮点数比较，可使用BigDecimal(数学工具类)!
- JDK7以后，数字之间可以使用下划线分割 10_0000_0000!
- 八大基本数据类型的默认值：
- int ：0
- String : null
- char : u0000
- boolean : flase
- 引用 : null
类型转换
由于java是强类型语言，所以要进行不同数据类型进行运算时，需要用到类型转换
精度由低到高依次为：
low ------------------------------------------------------------------------------------->high
byte,short,char --> int --> long --> float --> double
注意点：
-
转换的时候要注意内存溢出和精度问题！
-
不能对布尔值进行转换!
-
低转高不需要强制转换，高转低需要进行强制转换！
-
变量的定义格式如下
变量类型 变量名 = (强制转换类型)被强制转换对象名;
如以下代码中实例：
public class demo3 {
public static void main(String[] args) {
int a = 127;
byte b = (byte)a; //128则会内存溢出！！！
System.out.println(a);
System.out.println(b);
int money = 10_0000_0000;
int years = 20;
int total = money*years;
System.out.println("totak结果为："+total); //-1474836480,计算的时候溢出了
long total1 = money*years;
System.out.println("totak1结果为："+total1);//结果同上，因为在乘法结束后，其结果已经变为-1474836480，
long total2 = money*(long)years;
System.out.println("totak2结果为："+total2);
}
}
变量
变量是指程序运行过程中其值是可以改变的量。变量具有变量名，数据类型，变量值,作用域等基本属性。
注意点：
- 变量的定义格式如下
数据类型名 变量名表;
- 变量的赋值格式如下
变量名 = 初值或者表达式;
- 可将以上两点结合使用
type varName [=value] [{,varName[=value]}];
- 以上三条结尾均需要加上英文符号！
变量作用域
如以下代码中实例：
public class demo4 {
String name; //实例变量:从属于对象，如果不自行初始化，这个类型的默认值将为0 0.0等
int a; //boolean值默认为false &除了基本类型，其余的默认值都是null
static double salary =2500; //类变量
public static void main(String[] args) {
int i =10; //局部变量，必须声明和初始化值
System.out.println("i="+i);
//变量类型 ，变量名 = new demo4();
demo4 Demo4 = new demo4();
System.out.println("a="+Demo4.a);
System.out.println("name="+Demo4.name);
//类变量 static
System.out.println(salary);
}
public void add(){ //其他方法
}
}
变量命名规范
-
所有变量、方法名、类名都应该做到见名知意！
-
类成员变量：首字母小写和驼峰原则：monthSalary
-
局部变量：首字母小写和驼峰原则！
-
常量:大写字母和下划线：MAX_VALUE
-
类名：首字母大写和驼峰原则：Man,GoodMan
-
方法名：首字母小写和驼峰原则：run(),runTime()
常量
常量是指在程序运行过程中不允许被改变的值。
注意点：
- 常量使用大写字母表示，并使用 final 修饰
- 常量的定义格式如下
final 常量名 = 值;
final double PI =3.14；
如以下代码中实例：
public class demo5 {
static final double PI =3.1415926;
//static final double PI =3.1415926; 该语句亦可，修饰符不分先后顺序
public static void main(String[] args) {
System.out.println(PI);
}
}
暂定
运算符
java支持如下运算符
运算符优先级
单目乘除位关系，逻辑三目后赋值
单目：单目运算符+ –(负数) ++ – 等
乘除：算数单目运算符 / % + -
为：位移单目运算符<< >>
关系：关系单目运算符> < >= <= == !=
逻辑：逻辑单目运算符&& || & | ^
三目：三目单目运算符A > B ? X : Y
后：无意义，仅仅为了凑字数
赋值：赋值=*
二元运算符|
如以下代码中实例：
public class demo1 {
public static void main(String[] args) {
int a = 10; //二元运算符
int b = 10; //ctrl + d :复制当前行至下一行
int c = 10;
int d = 10;
System.out.println(a+b); //20
System.out.println(a-b); //0
System.out.println(a*b); //100
System.out.println(a/(float)b); //1.0
}
}
转换情形
当有long数据类型时，数据都会向long靠拢；当没有long数据类型时，所有非int类型都会转换为int类型
如以下代码中实例：
public class demo2 {
public static void main(String[] args) {
long a = 123123123123L;
int b = 123;
short c = 10;
byte d =8;
System.out.printf("a+b+c+d:%d\n",a+b+c+d); //long,123123123264
System.out.printf("b+c+d:%d\n",b+c+d); //int,141
System.out.printf("c+d:%d",c+d); //int,18
}
}
关系运算符
如以下代码中实例：
public class demo3 {
public static void main(String[] args) {
//关系运算符的返回结果：TRUE FALSE
int a = 10;
int b = 20;
int c = 21;
System.out.println("c%a="+c%a);
System.out.println(a>b); //false
System.out.println(a<b); //true
System.out.println(a==b); //flase
System.out.println(a!=b); //true
}
}
自加自减
如以下代码中实例：
public class demo4 {
public static void main(String[] args) {
//++ -- 一元运算符
int a = 3;
int b = a++; // a=4,b=3
int c = ++a; // c=5
System.out.println("a:"+a); // a=5
System.out.println("b:"+b); // b=3
System.out.println("c:"+c); // c=5
}
}
幂运算
如以下代码中实例：
public class demo5 {
public static void main(String[] args) {
double pow = Math.pow(3,2);
System.out.println(pow); //9.0
}
}
逻辑运算符（短路运算）
如以下代码中实例：
public class demo6 {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b)); //false
System.out.println("a || b:"+(a||b)); //true
System.out.println("a ! b:"+!(a&&b)); //true
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d); //false
System.out.println(c); //5
}
}
位运算
如以下代码中实例：
public class demo7 {
public static void main(String[] args) {
/* A = 0011 1100
B = 0000 1101
---------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
<< *2
>> /2
*/
System.out.println(2<<3); //16
}
}
扩展赋值运算符(面试题)
如下实例代码：
public class demo8 {
public static void main(String[] args) {
int a = 10;
int b = 20;
a+=b; //a=a+b
a-=b; //a=a-b
System.out.println(a);
//字符串连接符
System.out.println(""+a+b); //""1020
System.out.println(a+b+""); //30""
}
}
三元运算符
注意点：
- 三元运算符的定义格式如下
条件表达式 ？ 表达式A ： 表达式B //即条件表达式为真，则执行表达式A，否则执行表达式B
如下实例代码：
public class demo09 {
public static void main(String[] args) {
int score = 50;
String type = score <60 ? "不及格" : "及格";
System.out.println(type);
}
}
数组
数组是指具有相同数据类型的有序集合，其描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。
注意点：
- 必须先声明数组变量，才能在程序中使用数组！
- 数组的定义格式如下
dataType[] arrayRefVar; //首选方法,java特有，用于区分C&C++
dataType arrayRefVar[]; //次选方法，为了让C&C++工程师迅速适应开发而设定的
- Java语言使用new操作符来创建数组，定义格式如下
dataType[] arrayRefVar = new dataType[arraySize];
- 数组的元素是通过索引访问的，数组索引从0开始！
- 获取数组长度的方法，定义格式如下
arrays.length;
该语句表示下标越界！越界前的代码会继续执行直到越界位置！
如下实例代码：
public class demo1 {
public static void main(String[] args) {
int[] nums; //创建nums数组
nums = new int[10]; //定义nums数组
nums[0] = 0; //给nums中的元素赋值
nums[1] = 1;
nums[2] = 2;
for (int i = 0; i < nums.length; i++) { //length的长度从1开始，此处为10
System.out.println("nums["+i+"]"+nums[i]); //int默认值为0
}
}
}
数组的初始化
注意点：
-
数组的初始化分为三种:
-
静态初始化：int[] a = {1,2,3}; //数组a长度不可再被改变！！！！！！！！！！
Man[] mans = {new Man(1,1),new Man(2,2)};
-
动态初始化：int[] a = new int[2];
a[0]=1;
-
默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
-
如下实例代码：
public class demo2 {
public static void main(String[] args) {
//静态初始化：创建+赋值
int[] a = {1,2,3,4,5,6,7,8,9}; //数组a被初始化后不可修改长度
//动态初始化+默认初始化
int[] b = new int[10];
b[0] = 10;
}
}
数组的基本特点
注意点：
- 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的！
- 其元素必须是相同类型，不允许出现混合类型！
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型！
- 数组变量引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量！
- 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的！
数组边界
注意点：
- 下标的合法区间：[0,length-1],如果越界就会报错！
- ArrayIndexOutOfBoundsException：数组下标越界异常！
多维数组
注意点：
- 多维数组可以看出是数组的数组，如二维数组就是一个特殊的一维数组。其每一个元素都是一个一维数组！
- 二维数组的定义格式如下
int a[] [] = new int[2] [5];
- 三维数组的格式定义同上
如下实例代码：
public class demo4 {
public static void main(String[] args) {
int[][] array = {{1,2},{3,4},{5,6}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println("a["+i+"]"+"["+j+"]="+array[i][j]);
}
}
}
}
稀疏数组
稀疏数组是指为了节省一些不必要的数据而提出的特殊数组。其形式如同五子棋，未下棋处值为0，白棋为1，黑棋为2。
| 行(row) | 列(col) | 值(value) | |
|---|---|---|---|
| 0 | 6 | 5 | 4 |
| 1 | 0 | 3 | 1 |
| 2 | 0 | 4 | 1 |
| 3 | 3 | 1 | 1 |
| 4 | 6 | 0 | 1 |
如下实例代码：
public class demo8 {
public static void main(String[] args) {
// 0：空 1：黑棋 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+" ");
}
System.out.println();
}
//转换为稀疏数组保存
int sum = 0;
for (int i = 0; i < 11; i++) { //求有效值的和sum
for (int i1 = 0; i1 < 11; i1++) {
if (array1[i][i1]!=0){
sum++;
}
}
}
System.out.println("=======================================");
System.out.println("sum="+sum);
//创建一个稀疏数组
int [][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组将非零值存放到稀疏算法
int count=0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j]!=0) {
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
System.out.println("array:");
for (int i1 = 0; i1 < array2.length; i1++) {
System.out.println(array2[i1][0]+"\t"+array2[i1][1]+"\t"+array2[i1][2]+"\t");
}
}
}
流程控制
顺序结构
注意点：
- JAVA的基本结构就是顺序结构，除特别声明外，否则都按照顺序一句一句执行！
- 顺序结构是最简单的算法结构！
if单(多)(嵌套)选择结构
注意点：
- if单选择结构的定义格式如下
if(布尔表达式){} //如果布尔表达式为true，则将执行{}内的语句
- if多选择结构的定义格式如下
if(布尔表达式){
}else if(){
}else if()
else{}
- if嵌套结构的定义如下
if(布尔表达式1){
//如果布尔表达式1为true，则将执行{}内的语句
if(布尔表达式2){
//如果布尔表达式2为true，则将执行{}内的语句}}
判断输入的成绩属于什么评价
如下代码中实例：
public class demo5 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("input a score:");
int score = scanner.nextInt();
if (score==100){
System.out.println("nice,your score:"+score);
}else if(score>=85&&score<100){
System.out.println("good,your score:"+score);
}else if (score>=60&&score<85){
System.out.println("cool,your score:"+score);
}else if (score>=0&&score<60)
System.out.println("bad!your score:"+score);
else {
System.out.println("input illegal");
}
scanner.close();
}
}
switch多选择结构
注意点：
-
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支！
-
switch中的变量类型可为：
- byte, short, int, char
- 自Java SE7开始switch支持String类型
- 同时case标签必须为字符串常量或字面量
-
switch多选择结构的定义格式如下
switch(expression){
case value: //语句
case value: //语句 break; //可选
case value: //语句
default : //语句（可选）
}
使用switch判断等级并输出
如下代码中实例：
public class demo5 {
public static void main(String[] args) {
char grade = 'A'; //String grade = 'cyt',该语句亦可(注意点2)
switch (grade){
case 'A':
System.out.println("nice!");
break; //使用break防止穿透
case 'B':
System.out.println("good!");
break;
case 'C':
System.out.println("try a again");
break;
case 'D':
System.out.println("bad!");
break;
default:
System.out.println("unknown");
}
}
}
循环结构
while
注意点：
- while是最基本的循环，只要boolean表达式的值为true，循环就会一直执行下去，如服务器的请求响应监听！
- while循环结构的定义格式如下
while(boolea表达式){
//循环内容
}
使用while循环输出1~100
如下代码中实例：
public class demo6 {
public static void main(String[] args) {
int i =0;
while (i<100){
i++;
System.out.println(i);
}
}
}
使用while循环输出1+…+100的结果
如下代码中实例：
public class demo7 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
while (i<=100){
sum = sum + i;
i++;
}
System.out.println(sum);
}
}
使用while输出1~1000之间能被5整除的数
如下代码中实例：
public class demo11 {
public static void main(String[] args) {
int i = 1;
int m = 0;
int n = 1000;
while (i <= n){
if (i%5 == 0){
System.out.print(i+"\t");
m++;
if (m%3 == 0){
System.out.println();
}
}
i++;
}
}
}
do…while
注意点：
- do…while与while循环相似，不同点在于do…while至少会执行一次！
- do…while循环结构的定义格式如下
do {
//代码内容
}while(boole表达式);
使用do…while()输出1+…100的结果
如下代码中实例：
public class demo8 {
public static void main(String[] args) {
int i =0;
int sum =0;
do {
sum = i + sum;
i++;
}while (i<=100);
System.out.println(sum);
}
}
比较do…while与while的区别
如下代码中实例：
public class demo9 {
public static void main(String[] args) {
int a=0;
while (a<0){
System.out.println(a);
}
System.out.println("=====================");
do {
System.out.println(a);
}while (a<0);
}
}
for
注意点：
- for循环语句的次数支持迭代的一种通用结构，是最有效、最灵活的循环结构！
- for循环执行的次数是在执行前就确定的！
- for循环结构的定义格式如下
for( 初始化;Boolean表达式;更新){
//代码语句
}
-
for生成快捷键：100.for 将自动生成 for (int i = 0; i < 100; i++) {}；
-
for语句执行过程：
- 首先执行初始化。可以声明一种类型，可初始化一个或多个循环控制变量，亦可为空语句！
- 然后执行检测Boolean表达式的值，若结果为true则执行循环体的内容，若结果为false，循环将终结！
- 接着执行更新，更新循环变量！
- 再次检测Boolean表达式的值，循环！
计算0~100奇数、偶数和
如下代码中实例：
public class demo10 {
public static void main(String[] args) {
int oddsum = 0; //奇数的和
int evensum = 0; //偶数的和
for (int i = 0;i <= 100; i++){
if (i%2 == 1) {
oddsum += i;
}else {
evensum += i;
}
}
System.out.println("奇数和为："+oddsum);
System.out.println("偶数和为："+evensum);
}
}
使用for输出1~1000之间能被5整除的数
如下代码中实例：
public class demo12 {
public static void main(String[] args) {
for (int i = 1; i <=1000; i++){
if (i%5==0) {
System.out.print(i+"\t");
}
if (i%15==0){
System.out.println();
}
}
}
}
使用for输出99乘法表
如下代码中实例：
public class demo13 {
public static void main(String[] args) {
for (int i = 1;i <=9;i++ ){
for (int n =1;n <=i;n++){
System.out.print(n+"*"+i+"="+(n*i)+"\t");
}
System.out.println();
}
}
}
打印三角形
如下代码中实例：
public class demo16 {
public static void main(String[] args) {
for (int i = 5,n = 1; i > 0; i--){
for (int j = 1; j < i;j++) {
System.out.print(" ");
}
for (int j = 1; j <= n*2-1;j++){
System.out.print("*");
}
n++;
System.out.println();
}
}
}
同上：
public class demo17 {
public static void main(String[] args) {
for (int i = 1; i < 5; i++) {
for (int j = 5; j >=i; j--){
System.out.print(" ");
}
for (int j = 1; j <=i ; j++){
System.out.print("*");
}for (int j = 1; j < i ; j++){
System.out.print("*");
}
System.out.println();
}
}
}
增强for
注意点：
- 增强for是指Java5引入的一种主要用于数组和集合的增强型for循环。
- 增强for的定义格式如下
for(声明语句 : 表达式) //声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配，其 { 作用域限定在循环语句块，其值于此时数组元素的值相等。
//执行语句 //表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
}
增强for与for的比较
如下代码中实例：
public class demo14 {
public static void main(String[] args) {
int[] numbers = {10,20,30,40,50};
for (int i = 0; i < 5; i++) {
System.out.println(numbers[i]);
}
System.out.println("====================");
for (int x:numbers){
System.out.println(x);
}
}
}
break && continue && goto
注意点：
-
break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中的剩余语句！
-
continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断！
-
关于goto关键字：
-
尽管goto仍是java的一个保留字，但并未在语言中得到正式使用！
- 标签是指后面跟一个冒号的标识符，例如：*label*： - 对于*java*来说唯一用到标签的地方是在循环语句之前，而在循环之前设置标签的唯一理由是：希望在其中嵌套另一个循环，由于*break*和*continue*关键字通常只中断当前循环，但若随同标签使用，他们就会中断到存在标签的地方！
-
标签的使用
如下代码中实例：
public class demo15 {
public static void main(String[] args) {
int count = 0;
outer:for (int i=101;i<150;i++){
for (int j =2; j<i/2;j++ ){
if (i % j == 0){
continue outer;
}
}
System.out.println(i+" ");
}
}
}
方法
方法的定义(JAVA是值传递！！！！！！！！)
-
所谓静态方法即为可以直接调用的方法，其首字母为大写，如Arrays.toString();
-
非静态方法需要实例化对象来使用方法！
注意点：
-
在*System.out.println()*中：
-
System为系统类
-
out为对象
-
println为方法
-
-
Java方法是语句的集合，他们在一起执行一个功能：
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
-
设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。在设计方法的时候尽量保持方法的原子性，即一个方法只完成一个功能，这便于后期扩展
-
方法的定义格式如下
修饰符 返回值类型 方法名(参数类型 参数名){
…
//方法体
…
return 返回值;
}
- 修饰符：可选内容，告诉编译器如何调用该方法，定义了该方法的访问类型！
- 返回值类型：方法可能会返回值，returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值，在这种情况下，returnValueType是关键字void！
- 方法名：方法的实际名称。方法名和参数表共同构成方法签名！
- 参数类型：参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数！
- 方法体：方法体包含具体的语句，定义该方法的功能！
如以下代码中实例：
public class demo1 {
public static void main(String[] args) { //main方法
int sum = add(1,2);
System.out.println(sum);
}
public static int add(int a,int b){ //add方法
return a+b;
}
}
值传递实例
如以下代码中实例：
public class demo2 {
public static void main(String[] args) {
int a = 1;
System.out.println("调用前a："+a);
change(a);
System.out.println("调用后a："+a);
}
public static void change(int a){
System.out.println("调用过程中前a："+a);
a = 10;
System.out.println("调用过程中后a："+a);
}
}
引用传递实例
如以下代码中实例：
public class demo3 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
demo3.change(person);
System.out.println(person.name);
}
public static void change(Person person){
person.name = "cyt";
}
}
class Person{
String name; //默认null
}
方法的调用
注意点：
- 方法调用定义格式如下
对象名.方法名(实参列表)
- Java支持两种调用方法的方式，根据方法是否返回值来选择！
- 当方法返回一个值的时候，方法调用通常被当作一个值。例如：
int larger = max(30,40);
- 如果方法返回值是void，方法调用一定是一条语句。例如：
System.out.println(“hello，world！”)；
如以下代码中实例：
public class demo2 {
public static void main(String[] args) {
int i = max(2,3);
System.out.println(i);
}
public static int max(int a ,int b){
return a > b ? a : b;
}
}
方法的重写
注意点：
-
重写都是方法的重写，与属性无关！
-
方法的调用只和左边定义的数据类型有关！！！！！！！！！！！！！！！！！！！！！！！！！！
-
重写的关键字必须为public！
-
子类继承父类，子类重写父类！
-
方法名，参数列表必须相同，方法体不同！**
-
修饰符：范围可以扩大！ public > Protected > Default > private
-
抛出的异常：范围可以被缩小，但不能扩大！
-
重写快捷键：
- Alt + Insert ； override;
配合oop APPlication调用
如以下代码中实例：
public class B {
public void test() {
System.out.println("B=>test()");
}
}
public class A extends B {
@Override //重写
public void test() {
System.out.println("A=>test()");
}
}
方法的重载
重载是指在一个类中，有相同的函数名称，但形参不同的函数！
注意点：
- 方法名称必须相同！
- 参数列表必须不同:
- 个数不同
- 类型不同
- 参数排列顺序不同
- 方法的返回类型可以相同也可以不同！
- 仅仅返回类型不同不足以成为方法的重载！
- 实现理论：方法名相同时，编译器会根据调用方法的参数格式，参数类型等逐个去匹配，以选择对应的方法，如果匹配失败，编译器报错！
如以下代码中实例：
public class demo2 {
public static void main(String[] args) {
int i = max(2,3);
double n = max(2,3);
System.out.println("i:"+i);
System.out.println("n:"+n);
}
public static int max(int a ,int b){
return a > b ? a : b;
}
public static double max(double a ,double b){
return a > b ? a : b;
}
}
命令行传参
如以下代码中实例：
public class demo3 {
public static void main(String[] args) {
for (int i = 0;i < args.length;i++){
System.out.println("args["+"]:"+args[i]);
}
}
}
可变参数
如以下代码中实例：
- JDK1.5开始，Java支持传递同类型的可变参数给一个方法！
- 在方法声明中，在指定参数类型后面加一个省略号(…)！
- 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在他之前声明！
如以下代码中实例：
public class demo5 {
public static void main(String[] args) {
printMax(34,3,3,2,46,1.4,456.4);
printMax(new double[]{1,299,30});
}
public static void printMax(double... numbers){
if (numbers.length == 0){
System.out.println("no argument passed!");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length;i++){ //遍历数组寻得最大值
if (numbers[i] > result){
result = numbers[i];
}
}
System.out.println("the max numbers is:" + result);
}
}
方法之间的调用
- 当调用方法和被调用都未声明为Static时，各方法之间可相互调用！
- 当调用方法声明为Static，而被调用方法未声明为Static时，调用失败！
- 当被调用方法声明为Static，而调用方法未声明为Static时，调用成功！
如以下代码中实例：
public class demo1 {
public static void main(String[] args) {
}
public void a(){
c();
}
public static void b(){ //方法b调用失败
c(); //报错
}
public void c(){
}
}
如以下代码中实例：
public class demo1 {
public static void main(String[] args) {
}
public void a(){
c();
}
public static void b(){ //调用c方法成功
c();
}
public static void c(){
}
}
如以下代码中实例：
public class demo1 {
public static void main(String[] args) {
new demo1().a();
a(); //报错 //调用a失败
b();
}
public void a(){
}
public static void b(){
}
}
递归
递归是指自己调用自己的方法！合理利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的系统层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。能不用就不用！！！！！！！！！！！！！！！！！！！！！！！！！
注意点：
- 递归结构包括两个部分的内容：
- 递归头：递归程序结束的条件
- 递归体：调用递归的条件
如以下代码中实例：
public class demo6 {
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int n){
if (n == 1){
return 1;
}else {
return n*f(n-1);
}
}
}
暂定
包机制
包机制是指为了更好地组织类，java提供了包机制，用于区别类名的命名空间。其本质就是 文件夹！！！
注意点：
- 包语句的定义格式如下
package pkg1[. pkg2[. pkg3…]];
-
包名禁止重复！
-
一般利用公司域名倒置作为包名！ 如 www.baidu.com com.baidu.www
-
为了能够使用某一个包的成员，需要在java程序中明确导入该包！
-
导入包语句的定义格式如下
import package1[.package2…].(classname|);* *为通配符，将会导入这个包内的所有类
暂定
异常机制
异常是指程序运行中出现的不期而至的各种状况，如：文件找不到，网络链接失败，非法参数等！
注意点：
-
Java将异常分为以下三类：
-
检查性异常：最具代表性的检查性异常时是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略！
-
运行时异常：运行时异常时可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略！
- 在Exception分支中有一个重要的子类RuntimeException，其内容包含如下：
- ArrayIndexOutOfBoundEXception
- NullPointException
- ArithmeticException
- MissingResourceException
- ClassNotFoundException等异常，这些异常是不检查异常，程序中可以喧杂捕获处理，也可以不处理
- 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；
- 在Exception分支中有一个重要的子类RuntimeException，其内容包含如下：
-
错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略，例如，当栈溢出时，一个错误就发生了，他们在编译也检查不到！
-
Error类对象由Java虚拟机生成并抛出，大多数错误与代码所执行的操作无关！
-
Java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，OueOfMemoryError。这些异常发生时，JVM一般会选择线程终止！
-
还有发生在JVM视图执行应用时，如定义错误(NoClassDefFoundError)、链接错误(LinkageError)。这些错误是不可查的，因为他们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况！
-
-
Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，JVM一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常！
-
-
异常体系结构：
- Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类！
- 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception！
异常处理
异常处理是指抛出异常和捕获异常。
注意点：
- 异常处理有五个关键字：
- try catch finally throw throws
- 异常处理可以有多个catch，从上到下，范围逐渐扩大且互不相交！
如以下代码中实例：
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
try { //可使用快捷键快速包裹内容：ctrl + alt + t
System.out.println(a/b);
}catch (Error e){
System.out.println("程序异常Error！除数不能为0");
}catch (Exception e){ //Exception和Throwable不能调换顺序，需从小到大！
System.out.println("程序异常Exception！除数不能为0");
}catch (Throwable e){
System.out.println("程序异常Throwable！除数不能为0");
} finally{ //无论是否异常都执行finally
System.out.println("Finally");
}
}
}
如以下代码中实例：
public class Test2 {
public static void main(String[] args) {
int a = 1;
int b = 0;
/**try {
if (b == 0){ //主动抛出异常
throw new ArithmeticException();
}
System.out.println(a/b);
} catch (Exception e) {
System.exit(1); //可通过调用Sysytm.exit(1)提前结束
e.printStackTrace(); //打印错误的栈信息
} finally {
}*/
try {
new Test2().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
public void test(int a,int b) throws ArithmeticException{
if (b == 0) {
throw new ArithmeticException(); //主动抛出异常，一般在方法中使用
}
System.out.println(a/b);
}
}
自定义异常
自定义异常是指用户自定义的异常，其只需继承Exception类即可！
注意点：
-
创建自定义异常类的步骤：
-
创建自定义异常类
-
在方法中通过Throw关键字抛出异常对象。
-
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
-
在出现异常方法的调用者中捕获并处理异常。
-
如以下代码中实例：
public class MyException extends Exception{
private int detail;
public MyException(int a) {
this.detail = a;
}
@Override
public String toString() { //异常的打印信息
return "MyException{" +"detail=" + detail +'}';
}
}
public class Test3 {
static void test(int a) throws MyException{
System.out.println("a:"+a);
if (a>10){
throw new MyException(a);
}
System.out.println("ok!");
}
public static void main(String[] args) {
try {
test(11);
} catch (MyException e) {
System.out.println("MyException=>"+e);
}
}
}
实际应用中的经验总结
注意点：
- 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理！
- 在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常！
- 对于不确定的代码，也可以加上try-catch,处理潜在异常！
- 尽量去处理异常，切记只是简单地调用printStackTrace()去打印输出！
- 具体如何处理异常，则根据不同的业务需求和异常类型去决定！
- 尽量添加finally语句块去释放占用的资源！！！！！！！！！！
JavaDoc
***Javadoc*是指用来生成自己API文档的命令。
注意点：
-
参数信息包括
-
@author 作者名
- @version 版本号
-
since 指明需要最早使用的jdk版本
-
param 参数名
-
return 返回值情况
-
throws 异常抛出情况
-
-
如以下代码中实例：
package com.yt.compus.operator;
/**
* @author cyt
* @version 1.0
* @since 1.8
*/
public class demo10 {
String name;
/**
* @author cyt
* @param args
* @return
* @throws Exception
*/
public static void main(String[] args) {
}
}
暂定
Java内存分析
堆栈的区别：
暂定
创建与初始化对象(构造器)
创建与初始化对象
注意点：
- 使用new关键字创建对象的时候，除了分配内存空间以外，还会给创建好的对象进行默认的初始化以及对类中的构造器的调用！
- 类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能有void
- **alt + insert：**自动生成默认有参构造
配合oop APPlication调用
如以下代码中实例：
public class demo4 {
String name;
int age;
public demo4(String name,int age) {
this.name = name;
this.age = age;//alt + insert可快速生成构造，有参或无参
}
public demo4() {
}
@Override
public String toString() {
return "姓名："+name+"年龄："+age;
}
}
暂定
static关键字
注意点：
- 静态属性和方法可以直接通过类进行直接调用！
- 非静态属性和方法需要通过创建对象，间接通过对象调用！
如以下代码中实例：
public class Student2 {
private static int age = 12;
private double score = 90;
public void run(){
go(); //非static方法w，可直接调用static方法！
}
public static void go(){
}
public static void main(String[] args) {
Student2 s2 = new Student2();
System.out.println(Student2.age);
System.out.println(Student2.score); //报错，score非静态变量！
System.out.println(s2.age);
System.out.println(s2.score);
Student2.go();
Student2.run(); //报错，run非静态变量，不可调用！
s2.run();
s2.go();
}
}
静态代码块
如以下代码中实例：
public class demo6 {
{
System.out.println("匿名代码块"); //其次执行！
}
static {
System.out.println("静态代码块"); //最先执行！
}
public demo6(){
System.out.println("构造方法"); //最后执行！
}
public static void main(String[] args) {
demo6 person1 = new demo6();
System.out.println("=============");
demo6 person2 = new demo6(); //匿名和构造方法再次被执行，静态代码块不再被执行！
}
}
加static称为静态导入包
如以下代码中实例：
import static java.lang.Math.PI;
import static java.lang.Math.random; //加static称为静态导入包！
public class demo7 {
public static void main(String[] args) {
System.out.println(Math.random()); //导入前语法格式
System.out.println(random()); //导入后语法格式
System.out.println(PI);
}
}
Java特性
封装
注意点：
- 进行程序设计时，追求“高内聚，低耦合”，高内聚是类的内部数据操作细节自己完成，不允许外部干涉；低耦合是类仅暴露少量的方法给外部使用！
- 封装：一般情况下，应当禁止直接访问一个对象中数据的实际表示，而应当通过操作接口来访问，这被称为信息隐藏！
- 属性私有, get/set
配合oop APPlication调用
如以下代码中实例：
public class demo5 {
private String name;
private int id; //private为私有，无法直接在对象中通过.调用，可使用get()/set方法()
public char sex;
public String getName() {
return this.name;
}
public int getId() {
return this.id;
}
public void setName(String name) {
this.name = name;
}
public void setId(int id) {
if (id > 0 && id <1000){ //进行合法性判定
this.id = id;
}else {
System.out.println("id out of bound!");
}
}
}
暂定
继承
继承是指对某一批类的抽象，从而实现对现实世界更好的建模。继承是类与类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等。
注意点：
- extands:扩展，子类是父类的扩展！
- Java中类只有单继承，没有多继承！！！
- 继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extend来表示！
- 子类和父类之间，从意义上讲应该是“is a”的关系！
- 在Java中，所有的类都默认直接或者间接继承object类！！！！！！
配合oop APPlication调用
如以下代码中实例：
public class father {
private String fName;
public int fAge;
public void say(){
System.out.println("saying");
}
}
public class son extends father {
private String sName;
private int sAge;
}
super
w
注意点：
- super调用父类的构造方法，必须在构造方法的第一个！
- super必须只能出现在子类的方法或者构造方法中！
- super和this不能同时调用构造方法！
super vs this
注意点：
- this调用自身类或对象的成员变量或成员方法！
- 代表的对象不同：
- this： 本身调用着自身类或自身对象！
- super：代表父类对象的应用！
- 使用的前提不同：
- this：没有继承也可以使用！
- super只能在继承条件下才能使用！
- 构造方法不同：
- this()：自身类的构造！
- super()：父类的构造！
配合oop APPlication调用
如以下代码中实例：
public class father {
protected String fName = "czh";
public int fAge = 50;
public father() {
System.out.println("F:无参构造被执行");
}
public void say(){
System.out.println("F:saying");
}
}
public class son extends father {
private String sName = "cyt";
private int sAge = 22;
public void say(){
System.out.println("S:say");
}
public son() {
super(); //隐藏代码：调用了父类的无参构造
System.out.println("S:无参构造被执行");
}
public void test1(){
say();
this.say();
super.say();
}
}
oop APPlication
如以下代码中实例：
public class Application {
public static void main(String[] args) {
//类实例化，student是Student的实例
demo4 person = new demo4("cyt",12);
Student tom = new Student();
son cyt = new son();
tom.name = "tom";
tom.age = 12;
System.out.println("==========以下demo3==========");
System.out.println("name:"+tom.name);
System.out.println("age:"+tom.age);
System.out.println("==========以下demo4==========");
System.out.println(person);
System.out.println("==========以下demo5==========");
demo5 student = new demo5();
student.sex = 'm';
student.setName("cyt");
student.setId(21);
System.out.println(student.getName());
System.out.println(student.sex);
System.out.println(student.getId());
System.out.println("==========以下father && son==========");
cyt.test1();
}
}
多态
多态是指同一方法可以根据发送对象的不同而采用多种不同的行为方式， 动态编译：可扩展性！
注意点：
- 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多！
- 多态存在的条件：
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 多态是方法的多态，属性没有多态性！
- 子类可以调用自身方法以及继承自父类的方法！
- 父类可以指向子类，但无法调用子类的方法！
- 类型转换异常为： ClassCastException!
- 不可重写的方法：
- static //属于类，不属于实例
- final //常量
- private //
- 使用多态可以减少重复的代码！
instanceof
instanceof用于判断两个类直接的关系，如父子关系等。
oop APPlication
如以下代码中实例：
System.out.println(cyt instanceof son);
System.out.println(object instanceof father);
System.out.println(object instanceof Object);
System.out.println(object instanceof Student);
排序算法
冒泡排序
冒泡排序是指两层循环，外层冒泡轮数，里层依次比较。该算法的时间复杂度为O(n2)；
如以下代码中实例：
public class demo6 {
public static void main(String[] args) {
int[] array = {2,5,3,1,4};
int[] arrays = sort(array);
printArgs(arrays);
}
public static int[] sort(int[] array){
int temp = 0;
for (int i = array.length; i > 1; i--) {
for (int j = 0; j < i-1; j++) {
if (array[j] > array[j+1]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
return array;
}
public static void printArgs(int[] array){ //打印数组方法printArgs()
for (int i : array) {
System.out.println("i="+i);
}
}
}
============================================================================================================public class demo7 {
public static void main(String[] args) {
int[] a = {4,1,2,6,8,7,3,31,5,0,9};
int[] sort = sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
int temp = 0;
for (int i = 0; i < array.length - 1; i++) {
boolean flag = false; //用于提前结束循环以节省不必要的时间
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1] < array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if (flag==false){
break;
}
}
return array;
}
}
Java类
abstract类
注意点：
- abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类！
- 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类，即抽象方法必须在抽象类中！
- 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的！
- 抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的！
- 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类！
- 抽象类中可以写普通方法！
- 抽象类存在的意义：进一步抽象以太高开发效率！
如以下代码中实例：
public abstract class demo8 {
public abstract void doSomething();
}
demo8 && demo9
如以下代码中实例：
public abstract class demo8 {
public abstract void doSomething();
public static void go(){
System.out.println("go!");
}
}
public class demo9 {
public static void main(String[] args) {
demo8 g = new demo8() {
@Override
public void doSomething() {
System.out.println("doSomething!");
}
};
g.doSomething();
g.go();
}
}
Arrays类
注意点:
- 数组的工具类java.util.Arrays
- 由于数组对象本身并没有什么可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操！
- 可查看JDK帮助文档
- Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用！不用不等于不能！
- Arrays具有以下常用功能：
- 给数组赋值：通过fill方法！
- 对数组排序：通过sort方法，默认升序！
- 比较数组：通过equals方法比较数组中元素值是否相等！
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作！
public class demo5 {
public static void main(String[] args) {
int[] a = {12,41,21,1,5,7457,234,1,4,8456};
int[] b = new int[10];
int[] c = new int[10];
Arrays.fill(b,1);
Arrays.fill(c,0,10,1); //Arrays.file(int[],start,end,num),左闭右开！！！！！！！！！！
Arrays.sort(a);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
if (Arrays.equals(b,c)){
System.out.println("Equals!");
}else {
System.out.println("Not equals!");
}
}
}
Scanner类
Scanner对象是指java提供的一个工具类，可以获取用户的输入，java.util.Scanner是java5的新特新，可通过该特性以获取用户的输入。
注意点：
- Scanner对象的定义格式如下
Scanner s = new Scanner(System.in);
-
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用*hasnext()与hasNextLine()*判断是否有输入的数据！
-
*next()*中不得携带空格，空格将被视为输入完成！
-
nextLine()以enter作为结束符，即可携带空格！
提示用户输入内容并将输入内容原样输出
如以下代码中实例：
public class demo1 { public static void main(String[] args) { //创建一个扫描器对象，用于接收键盘数据 Scanner scanner = new Scanner(System.in); //alt+enter自动生成 System.out.println("使用next方式接收："); //判断用户有没有输入字符串 if (scanner.hasNext()){ //接收用户的输入 String str = scanner.next(); //程序等待用户输入完毕 System.out.println("输入的内容为："+str); } //习惯性关闭I/O流，否则会一直占用资源 scanner.close(); } }提示用户输入内容并将输入内容原样输出
public class demo2 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("'使用nextLine方式接收："); //判断用户有无输入字符 if (scanner.hasNextLine()){ //使用next方式接收 String str = scanner.nextLine(); //程序会等待用户输入完毕 System.out.println("输出的内容为:"+str); } //习惯性关闭I/O流，否则会一直占用资源 scanner.close(); } }
如果输入的内容为数字，若为整数则输出该整数，并继续输入判断是否为小数
public class demo3 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i = 0;
float f = 0;
System.out.println("input a num:");
if (scanner.hasNextInt()){
i = scanner.nextInt();
System.out.println("int num:"+i);
}
else {
System.out.println("input the num not a int!");
}
System.out.println("input a float:");
if (scanner.hasNextFloat()){
f = scanner.nextFloat();
System.out.println("float num:"+f);
}else {
System.out.println("input a num not a float!");
}
}
}
输入多个数字，求其综合及平均数，若输入的内容非数字则结束输入并输出结果：
public class demo4 {
public static void main(String[] args) {
double sum = 0.0; // sum为和
int m = 0; // m为每次输入的数
Scanner scanner = new Scanner(System.in);
System.out.println("input a num:");
while (scanner.hasNextDouble()){
double x = scanner.nextDouble(); //x为临时变量，用于接收输入的数
sum +=x;
m++;
}
System.out.println("sum:"+sum);
System.out.println("times："+m);
System.out.println("average："+(sum/m));
scanner.close();
}
}
判断字符串是否相等：
public class demo6 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("input a String:");
String s = scanner.nextLine();
if (s.equals("hello")){ //equals：判断字符串是否相等
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
面向对象编程(OOP)
面向对象编程是指对于描述复杂的事物，为了从宏观上把握、从整体上分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。Java的核心思想就是面向对象编程！
注意点：
- 面向对象编程的本质就是：以类的方式组织代码，以对象的形式组织(封装)数据。
- 三大特性：
- 封装
- 继承
- 多态
- 从认识论角度考虑是先有对象后有类。对象，是具体的事务。类，是抽象的，是对对的抽象。
- 从代码运行角度考虑是先有类后有对象。类是对象的模板。
类与对象的关系
注意点：
- 类是一种抽象的数据类型，他是对某一类事务整体描述/定义，但是并不能代表某一个具体的事物！
- 对象是抽象概念的具体实例！
暂定
内部类
内部类是指在一个类的内部在定义一个类。如在A类中定义一个B类，那么B类相对于A类即为内部类，而A类相对于B类来说就是外部类！
注意点：
- 内部类可划分为：
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
成员内部类
如以下代码中实例：
public class demoOuter {
private int id = 10;
public void out(){
System.out.println("it's out!");
}
public class Inter{
public void in(){
System.out.println("it's in!");
}
public void getID(){
System.out.println(id);
}
}
}
public class OuterUse {
public static void main(String[] args) {
demoOuter outer = new demoOuter();
demoOuter.Inter inner = outer.new Inter();
inner.in();
inner.getID();
}
}
暂定
接口
注意点：
-
普通类、抽象类、接口之间的区别：
- 普通类：只有具体实现
- 抽象类：具体实现和规范(抽象方法)都有
- 接口：只有规范(抽象方法)
-
接口的本质是契约！
-
implements可以实现多个接口！
-
必须重写接口中的方法！
如以下代码中实例：
public interface interFaceDemo10{ //interface接口定义关键字，接口都需要有实现类
void add(String name); //接口中的所有定义都是抽象的
void delete(String name);
void update(String name);
void query(String name);
}
public class UseServiceImpl implements interFaceDemo10{ //类可以实现接口 implements 接口
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
暂定
反编译操作(idea)
.java程序可通过idea进行反编译
暂定
综合应用
基础语法篇
计算器
如以下代码中实例：
public class demo7 {
public static void main(String[] args) {
double result =0;
Scanner scanner = new Scanner(System.in);
System.out.println("input your first num a:");
double a = scanner.nextDouble();
System.out.println("input your signal:");
String c =scanner.next();
System.out.println("input your first num b:");
double b = scanner.nextDouble();
switch (c){
case "+" : result = add(a,b);break;
case "-" : result = sub(a,b);break;
case "*" : result = mul(a,b);break;
case "/" : result = div(a,b);break;
}
System.out.println(a+c+b+"="+result);
scanner.close();
}
public static double add(double a,double b){
return a + b;
}
public static double sub(double a,double b){
return a - b;
}
public static double mul(double a,double b){
return a * b;
}
public static double div(double a,double b){
return a / b;
}
}
数组倒置
如以下代码中实例：
public class demo3 {
public static void main(String[] args) {
int[] arrays= {1,2,3,4,5};
printArgs(reverse(arrays));
}
public static int[] reverse(int[] array){ //倒置数组方法reverse()
int[] arrays = new int[array.length];
for (int i = 0,j = array.length-1; i < array.length; i++,j--) {
arrays[i] = array[j];
}
return arrays;
}
public static void printArgs(int[] array){ //打印数组方法printArgs()
for (int i : array) {
System.out.println("i="+i);
}
}
}
```
363
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
