一个.java文件可以存放多个类(不建议),但只有一个类可以使用public修饰,该类的类名必须与文件名保持一致
一、两个数调换
// 方法一
int a = 5;
int b = 8;
a = a^b;
b = a^b;
a = a^b;
//方法二
int a = 5;
int b = 8;
int temp = a;
a = b;
b = temp;
//方法三
int a = 5;
int b = 8;
a = a+b;
b = a-b;
a = a-b;
二、冒泡排序
外层循环控制行,内层循环控制列,内存循环每次循环(数组长度-1-i)词,内部判断循环到的这个数和下一个哪个大,调换位置
三、数组的内存原理
数组内部存放的是地址
数组的值输出方法:Arrays.toString(arrs);
四、方法
1、有参数有返回值的方法:必须存在返回值,返回值类型必须与规定的保持一致,传参
2、无参数有返回值的方法:必须存在返回值,返回值类型必须与规定的保持一致,不传参
3、有参数无返回值:允许使用return,但不能返回具体的值,传参
4、无参数无返回值:允许使用return,但不能返回具体的值,不传参
【
有返回值:直接调用、直接输出、用变量接
无返回值:直接调用
】
五、递归
自己对自己的调用,通过不断地调用自己,在达到某种条件后,停止调用
import java.util.Scanner;
/**
* 求n的阶乘
* @author again
*/
public class Test {
//主方法
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(print(sc.nextInt()));
}
//递归方法
public static long print(int n) {
if(n == 2) {
return 1;
}
return (long)n * print(n-1);
}
}
六、扑克练习
一个数组存放花色,一个数组存放牌面,通过外界count变量的自增,从而为54张牌赋值(大小王为特例)
洗牌的时候,遍历扑克牌将遍历到的排的位置与随机生成的牌的位置互换
package cn.edu.again.day16:
/**
* 扑克牌
*/
import java.util.Arrays;
import java.util.Random;
public class Test9 {
public static void main(String[] args){
System.out.println(Arrays.toString(shade()));
System.out.println(Arrays.toString(Xi(shade()));
Fa(Xi(shade()));
}
/**
* 准备牌
* @return
*/
public static String[] shade() {
String[] pai = new String[54];
String[] color = {"♥","♠","♣","♦"};
String[] side = {"A","2","3","4","5","6","7","8""9","10","J","Q","K"};
int count = 0;
for (int i = 0; i < color.length; i++) {
for (int j = 0;j < side.length; j++) {
pai[count] = color[i] + side[j];
count++;
}
}
pai[52] ="大王";
pai[53] ="小王";
return pai;
}
/**
* 洗牌
* @param pai
* @return
*/
public static String[] Xi(Stringl pai) {
Random r = new Random();
for (int i = 0; i < pai.length; i++) {
String temp = pai[il;
int a = r.nextInt(54);
pai[i] = pai[a];
pai[a] = temp;
}
return pai;
}
/**
* 发牌
* @param pai
*/
public static void Fa(Stringl pai) {
String[] a = new String[54/3 - 1];
String[] b = new String[54/3 - 1];
String[] c = new String[54/3 - 1];
String[] d = new String[3];
int count = 0;
for (int i = 0; i < pai.length-3; i++) {
switch (i%3) {
case 0:
a[count] = pai[i];
break;
case 1:
b[count] = pai[i];
break;
case 2:
c[count] = pai[i];
count++;
break;
default:
break;
}
}
d[0] = pai[51];
d[1] = pai[52];
d[2] = pai[53];
System.out.println("第一位玩家:"+Arrays.toString(a));
System.out.println("第二位玩家:"+ Arrays.toString(b));
System.outprintln("第三位玩家:"+Arrays.toString(c));
System.out.println("底牌:"+ Arrays.toString(d));
}
}
七、内存管理
1、栈内存
正在被调用的方法;
栈帧:存放变量内容(基本数据类型)和变量地址(引用数据类型)
2、堆内存
存放对象,new出来的东西
3、方法区
用于存放.class文件和未被调用的方法(实体类中被创建的方法也在这里,但是实体类会存放指向这里的地址)
八、实体类
1、成员变量(属性)
2、成员方法(行为)
方法的重载:方法的重载是针对具有类似功能的一系列方法,它们具有相同的方法名,不同的形参列表,返回值不关心
3、构造器
有参构造器
无参构造器
4、代码块
静态代码块
实例代码块
5、内部类
九、对象的使用
对象 对象名 = new 对象;
对象.变量 = 值;
对象.方法();
十、二进制转十进制
package cn.edu.again.day17;
import java.util.Scanner;
/**
* 二进制--十进制1000
* 方法一
* 1 0 0 0 0 * 10^0 ... 1*2 3 1 0 0 1*2^2 1,0,0,0
* @author Again
*/
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个二进制数:");
String a = sc.next0;
System.out.println(adapter(a)):
}
/**
* 转换:二进制--十进制
* @param a
* @return
*/
private static int adapter(String a) {
int result = 0
char[] chars = a.toCharArray();
for (int i = 0; i < chars.length; i+ +) {
if (chars[i] != '0' && chars[il != '1') {
System.out.println("您输入的数据有误!");
return -1;
}
//int n = a.charAt(0) - '0';
// 字符转字符串
String c = String.valueOf(chars[i);
// 字符串转整型 Integer.parselnt(C)
result += Integer.parselnt(c) * (Math.pow(2, chars.length - 1 - i));
}
return result;
}
}
十一、this、super关键字
this | super | |
访问构造方法 | this() | supper |
访问成员变量 | this.成员变量 | super.成员变量 |
访问成员方法 | this.成员方法() | super.成员方法() |
this与super均用于构造器的第一行,不写默认存在super(),可以用this()调用重载构造器,但this()和super()只能存在一个
十二、NullPointerException
普通方法需要由对象才能够被调用 ,如果对象为null则会报空指针异常
十三、值传递
java在进行参数传递的时候采用的是值传递,但数据类型为基本数据类型的时候,传的是数据,当数据类型为引用数据类型的时候,传的是地址
十四、继承extends
1、面向对象三大特征:封装、继承、多态
2、一个子类只允许有一个直接父类,所有类要么直接继承Object类,要么间接继承Object类,Object是祖宗类
3、子类的功能更强大
4、子类可以使用父类的方法
5、子类可以重写父类的方法