JAVA基础知识_WEEK01

一个.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、子类可以重写父类的方法