宋红康java基础学习笔记 | MissPower007博客

Java

Web

发布日期: 2022-02-10

更新日期: 2022-02-22

阅读次数: 598

基础知识

JDK：Java开发工具包，包括 JRE，编译工具：javac.exe，打包工具：jar.exe

JRE：Java运行环境，包括 jvm

数据类型

基本数据类型

字符型

byte
short
int
long，long l1 = '11111111111L';（结尾要加 l ）
float，float f1 = 3.14f;（结尾要加 f）
double

字符型

char，char a = 's';（必须是单引号）

布尔型

bool

基本数据类型之间的运算

前提：不包含 boolean

自动类型提升

含义：容量小的与容量大的数据类型变量做运算时，结果自动提升为容量大的数据类型
```
//
byte a = 1;
int b = 2;
int c = a + b;

//
short a = 10;
char b = 'a';
int c = a + b;
```
特别的：当byte、char、short三种变量做运算时结果为int类型
强制类型转换

强转符：()
```
double a = 3.9;
int c = (int)a;
```

整型常量默认类型为 int

浮点型常量默认类型为 double

引用数据类型

类（class）字符串在这里，String a = "abc";（必须用双引号）
接口（interface）
数组（[]）

String

String无法转为int

String str1 = 123 + "";
int num1 = (int)str1; //报错，String 无法转为 int

运算符

算术运算符

+
-
*
/
%
a++，先取值后运算
++a，先运算后取值
a--
--a

赋值运算符

比较运算符

>
<
==，==比较地址，equals比较值
!=
>=
<=

逻辑运算符

|
||，开发中推荐使用
&
&&，开发中推荐使用
!
^

位运算符

<<，左移
>>，右移
>>>，无符号右移
&，与运算
|，或运算
^，异或运算
~，取反运算

三元运算符

凡是可以使用三元运算符的地方都可以改写为if-else

(条件表达式)?表达式1:表达式2;

运算符的优先级

想要先运算的加括号就可以

实例

交换顺序

//method1
//弊端：相加操作可能超出范围
class Test{
    public static void main(String[] args){
        int a = 5;
        int b = 10;
        //交换a和b的顺序
        a = a + b;
        b = a - b;
        a = a - b;
        System.out.println(a);
        System.out.println(b);
    }
}

//method2
class Test{
    public static void main(String[] args){
        int a = 5;
        int b = 10;
        a = a^b;
        b = a^b;
        a = a^b;
        System.out.println(a);
        System.out.println(b);
    }
}

流程控制

顺序结构

从上到下顺序执行

分支结构

if-else

//method1
if(条件){
    代码;
}

//method2
if(条件){
    代码;
}else{
    代码;
}

//method3
if(条件){
    代码;
}else if(条件1){
    代码;
}else if(条件2){
    代码;
}else{
    代码;
}

switch-case

/**
1.不加break会顺序执行,
2.表达式可以是哪些类型？byte/short/char/int/枚举类型/String, **注意不可以是boolean类型
3.常量不能有范围
*/
switch(表达式){
    case 常量1:
        语句1;
        //break;
    case 常量2:
        语句2;
        //break;
    case 常量3:
        语句3;
        //break;
    default:
        语句;
        //break;
}

循环结构

for

for(;;){

}

while

while(){

}

do-while

do{

}while();

嵌套循环

/**
输出下列图形：
    *
   * *
  * * *
 * * * *
* * * * *
 * * * *
  * * *
   * *
    *
*/

class Test{
    public static void main(String[] args){
        //上三角
        for (int a = 1;a <= 5;a++) {
            for (int b = 1;b <= 5 - a;b++) {
                System.out.print(" ");
            }
            for (int c = 1;c <= a;c++) {
                System.out.print("* ");
            }
            System.out.print("\n");
        }

        //下三角
        for (int a = 1;a <= 4;a++) {
            for (int b = 1;b <= a;b++) {
                System.out.print(" ");
            }
            for (int c = 1;c <= 5 - a;c++) {
                System.out.print("* ");
            }
            System.out.print("\n");
        }
    }
}

/**
求完数
*/
class Test{
    public static void main(String[] args){
        long start = System.currentTimeMillis();

        boolean flag = true;
        int sum;
        for (int i = 1;i < 1000;i++) {
            flag = true;
            sum = 0;
            for (int j = 1;j <= i/2+1;j++) {
                if (i % j == 0) {
                    sum = sum + j;
                }
            }
            if (sum == i) {
                System.out.println(i);
            }
        }

        long end = System.currentTimeMillis();
        System.out.println("time = "+ (end - start));
    }
}

break-continue

break：结束当前循环
continue：结束本次循环，跳入下一次循环

/**
带标签的break和continue
*/
class Test{
    public static void main(String[] args){
        lable1:for (int a = 1;a <= 5;a++) {
            for (int b = 1;b <= 5;b++) {
                if (b % 4 == 0) {
                    continue lable1;
                }
                System.out.print("*");
            }
            System.out.print("\n");
        }
    }
}

/**
求质数
*/
class Test{
    public static void main(String[] args){
        long start = System.currentTimeMillis();

        boolean flag = true;
        for (int i = 1;i < 10000;i++) {
            flag = true;
            //优化一：对本身是质数的数进行优化
            for (int j = 2;j <= Math.sqrt(i);j++) {
                if (i % j == 0) {
                    flag = false;
                    //优化二:对不是质数的数进行优化
                    break;
                }
            }
            if (flag == true) {
                System.out.println(i);
            }
        }

        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

常见类-方法

Math

Math.random()

/**
获取随机数
Math.random()       //[0,1)
(int)Math.random()  //0
*/
double value = Math.random()*90+10;             //[10,99),double
int value = (int)Math.random()*90+10;           //[10,99),int
int value = (int)(Math.random()*(b-a+1)+a);     //[a,b],int

Math.currentTimemillis()

/**
获取时间
*/
long start = Math.currentTimemillis();
long end = Math.currentTimemillis();
long time = end - start;

Scanner

/**
获取用户输入
*/
import java.util.Scanner;

class Test{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        //整数型输入
        int num = scan.nextInt();
        System.out.println("your num is "+num);

        //字符串输入
        String str = scan.next();
        System.out.println("your str is "+str);

        //char类型
        char c = str.charAt(0);
        System.out.println(c);
    }
}

Arrays

import java.util.Arrays;
public class Array {
    public static void main(String[] args) {
        int[] arr1 = new int[]{-6,7,10,-1,-100,99,99,-1};
        int[] arr2 = new int[]{-6,7,10,-1,-100,99,99,-1};
        //比较两个数组是否相等
        boolean flag = Arrays.equals(arr1,arr2);
        System.out.println(flag);

        //数组填充
        Arrays.fill(arr1,1);
        System.out.println(Arrays.toString(arr1));

        //排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        //二分查找
        int index = Arrays.binarySearch(arr2,100);
        System.out.println(index);
    }
}

IDEA使用

快捷键

main
sout
get
set

数组

基础

定义：

多个相同类型数据按一定顺序排列的集合

常见名词：

数组名
下标
元素
数组长度

内存：

创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址
数组的长度一旦确定，就不能修改

元素默认初始化值：

整型：0
浮点型：0.0
char型：0或'\u0000'
boolean型：false
String型：null

数组使用

//一维数组的声明和初始化
 public class Array {
    public static void main(String[] args) {
        //方式一，静态初始化，数组初始化和数组元素赋值同时进行
        int[] array1 = new int[]{1,2,3};
        //方式二，动态初始化，数组初始化和数组元素赋值分开进行
        int[] array2 = new int[3];
        array2[0] = 1;
        array2[1] = 2;
        array2[2] = 3;
        //方式三
        int[] array3 = {1,2,3};

        //遍历输出数组方式一
        for (int i = 0;i < array1.length;i++){
            System.out.println(array1[i]);
        }
        //遍历输出数组方式二
        for (int element:array1){
            System.out.println(element);
        }
    }
}

二维数组

//二维数组的声明和初始化
public class Array {
    public static void main(String[] args) {
        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5,6},{7}};
        //遍历
        for (int[] e:arr1){
            for (int s:e){
                System.out.print(s);
            }
            System.out.println();
        }

        //动态初始化1
        int[][] arr2 = new int[3][3];
        arr2[0][0] = 1;
        arr2[0][1] = 2;
        arr2[1][0] = 3;
        arr2[1][1] = 4;
        //遍历
        for (int[] e:arr2){
            for (int s:e){
                System.out.print(s);
            }
            System.out.println();
        }

        //动态初始化2
        int[][] arr3 = new int[3][];
        arr3[0] = arr2[0];
        arr3[1] = arr2[1];
        arr3[2] = arr2[2];

        //输出null（空指针）
        System.out.println(arr3[0]);
        //报错：空指针异常
        System.out.println(arr3[0][1]);
        //遍历
        for (int[] e:arr3){
            for (int s:e){
                System.out.print(s);
            }
            System.out.println();
        }

        //动态初始化3
        int[] arr4[] = new int[3][];
    }
}

//杨辉三角
public class Array {
    public static void main(String[] args) {
        //初始化
        int[][] arr = new int[10][];
        //每一行首位为1
        for (int i = 0;i < 10;i++){
            arr[i] = new int[i+1];
            arr[i][0] = 1;
            arr[i][i] = 1;
        }
        //第三行开始杨辉三角
        for (int i = 2;i < 10;i++){
            for (int j = 1;j < i;j++){
                //关键部分
                arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
            }
        }

        //遍历
        for (int[] e1:arr){
            for (int e2:e1){
                System.out.print(e2+",");
            }
            System.out.println();
        }
    }
}

//一维数组长度为6，元素值都在1-30之间，是随机值，同时要求各个元素值不相同
public class Array {
    public static void main(String[] args) {
        int[] arr = new int[6];     //初始化一维数组
        int random;                 //声明随机数
        boolean flag = true;        //声明循环条件
        for (int i =0;i < arr.length;i++){
            //无限循环，直到获得满足条件的随机数
            label1:for(;;) {
                //生成随机数
                random = (int) (Math.random() * 30 + 1);
                //判断当前生成的随机数是否与其他元素值相等
                for (int j = 0; j < arr.length; j++) {
                    if (i != j) {
                        if (random == arr[j]) {
                            continue label1;
                        }
                    }
                }
                //赋值，并跳出循环
                arr[i] = random;
                break;
            }
        }

        //遍历输出
        for (int e:arr){
            System.out.print(e+" ");
        }
    }
}

//回形数算法
import java.util.Scanner;
public class Array {
    public static void main(String[] args) {
        //获取用户输入
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入回形数：");
        int num = scan.nextInt();

        //生成回形数数组
        int[][] arr = new int[num][num];
        int direction = 1;
        int i = 0;      //当前行
        int j = 0;      //当前列
        int minI = 0;       //最小行
        int maxI = num - 1; //最大行
        int minJ = 0;       //最小列
        int maxJ = num - 1; //最大列
        int count = 1;      //计数，1-25

        while (count <= num*num) {
            switch (direction) {
                //向右
                case 1:
                    if (minJ <= j && j <= maxJ) {
                        arr[i][j++] = count++;
                    }else{
                        minI++;
                        i++;
                        j--;
                        direction = 2;
                    }
                    break;
                //向下
                case 2:
                    if (minI <= i && i <= maxI){
                        arr[i++][j] = count++;
                    }else{
                        maxJ--;
                        i--;
                        j--;
                        direction = 3;
                    }
                    break;
                //向左
                case 3:
                    if (minJ <= j && j <= maxJ){
                        arr[i][j--] = count++;
                    }else{
                        maxI--;
                        j++;
                        i--;
                        direction = 4;
                    }
                    break;
                //向上
                case 4:
                    if (minI <= i && i <= maxI){
                        arr[i--][j] = count++;
                    }else{
                        minJ++;
                        i++;
                        j++;
                        direction = 1;
                    }
                    break;
            }
        }

        //遍历输出
        for (int[] e1:arr){
            for (int e2:e1){
                System.out.print(e2+"\t");
            }
            System.out.println();
        }
    }
}

内存解析

基础：

栈（stack）：存放局部变量
堆（heap）：存放new出来的结构（对象、数组）
方法区：常量池、静态域

实例：

//思考下面代码的内存分配过程
int[] arr = new int[]{1,2,3};
String[] arr1 = new String[4];
arr1[1] = "刘德华";
arr1[2] = "张学友";
arr1 = new String[3];

数组复制

深复制
浅复制

//结果：0 3 2 7 4 
public class Array {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1,3,5,7,9};
        int[] arr2;

        arr2 = arr1;    //复制操作，arr1和arr2都指向同一个数组，数组变化则arr1和arr2都变化

        for (int i = 0;i < arr2.length;i=i+2){
            arr2[i] = i;
        }

        for (int e:arr1){
            System.out.print(e+" ");
        }
        System.out.println();
    }
}

数组反转

public class Array {
    public static void main(String[] args) {
        String[] arr1 = new String[]{"a","b","c","d","e","f","g"};

        for (int i = 0,j = arr1.length - 1;i < j;i++,j--){
            String tmp = arr1[i];
            arr1[i] = arr1[j];
            arr1[j] = tmp;
        }

        //遍历输出
        for (String e:arr1){
            System.out.print(e+" ");
        }
        System.out.println();
    }
}

数组查找

线性查找，一个接一个的查找
二分法，要求数组有序

//二分法
public class Array {
    public static void main(String[] args) {
        int[] arr = new int[]{-10,-6,4,9,20,45,100};
        int dest = 19;      //要寻找的数
        int head = 0;
        int end = arr.length-1;
        boolean flag = true;
        while (head <= end){
            int middle = (head + end)/2;
            if (dest == arr[middle]){
                System.out.println("位置是："+middle);
                flag = false;
                break;
            }else if (dest > arr[middle]){
                head = middle + 1;
            }else{
                end = middle - 1;
            }
        }
        if (flag){
            System.out.println("很遗憾没有找到！");
        }
    }
}

数组排序

冒泡排序
快速排序

//冒泡排序
public class Array {
    public static void main(String[] args) {
        int[] arr = new int[]{-6,7,10,-1,-100,99};
        int tmp;

        //开始冒泡
        for (int j = 1;j < arr.length-1;j++) {
            for (int i = 0; i < arr.length-j; i++) {
                if (arr[i] > arr[i + 1]) {
                    tmp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = tmp;
                }
            }
        }

        //遍历输出
        for (int e:arr){
            System.out.print(e+" ");
        }
    }
}

数组异常

数组下标越界的异常：ArrayIndexOutOfBoundsException
空指针异常：NullPointerException

public class Array {
    public static void main(String[] args) {
        //ArrayIndexOutOfBoundsException
        int[] arr1 = new int[3];
        System.out.println(arr1[3]);

        //NullPointerException
        arr1 = null;
        System.out.println(arr1[0]);

        //NullPointerException
        int[][] arr = new int[4][];
        System.out.println(arr[0][0]);

        //NullPointerException
        String[] arr = new String[]{"a","b","c"};
        arr[0] = null;
        System.out.println(arr[0].toString());
    }
}

数组中的特殊情况

char 类型数组可以直接使用数组名打印，直接输出字符串。char 类型的数组就相当于一个字符串。

public class ClassTest {
    public static void main(String[] args) {
        char[] arr = new char[] { 'a', 'b', 'c' };
        System.out.println(arr);
        int[] arr1 = new int[] { 1, 2, 3 };
        System.out.println(arr1);
        double[] arr2 = new double[] { 1.1, 2.1, 3.1 };
        System.out.println(arr2);
    }
}

/**
 * 结果：
 * abc
 * [I@1b6d3586
 * [D@4554617c
 */

面向对象

学习主线

Java类及类的成员：属性、方法、构造器；代码块、内部类
面向对象的三大特征：封装性、继承性、多态性
其他关键字：this、super、static、final、abstract、interface

类和对象

属性和方法

//Demo
//属性：field
//方法：method
public class ClassTest {
    public static void main(String[] args){
        //创建Personl类的对象
        Person p1 = new Person();

        //调用属性
        p1.name = "Tom";
        p1.isMale = true;
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.isMale);

        //调用方法
        p1.eat();
        p1.sleep();
        p1.talk("汉语");
    }
}


//定义Person类
class Person{
    //属性
    String name;
    int age = 1;
    boolean isMale;

    //方法
    public void eat(){
        System.out.println("人可以吃饭");
    }
    public void sleep(){
        System.out.println("人可以睡觉");
    }
    public void talk(String language){
        System.out.println("人可以说话，我说的是"+language);
    }
}

对象的内存解析

自行脑补

堆：存放对象实例
栈：指虚拟机栈，存储局部变量（方法中的变量都是局部变量）
方法区：存储类信息、常量、静态变量

属性VS局部变量

相同点：

定义变量的格式相同
都是先声明后使用
变量都有其对应的作用域

不同点：

在类中声明的位置不同
- 属性声明在{}中
- 局部变量声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
关于权限修饰符不同
- 属性：可以在声明时，指明其权限，使用权限修饰符
  - 常用的权限修饰符：private、public、缺省、protected。（权限修饰符提现了封装性）
- 局部变量：不可以使用权限修饰符
默认初始化值不同
- 类的属性：根据其类型，都有默认初始化值
  - 整型（byte/short/int/long）：0
  - 浮点型（float/double）：0.0
  - 字符型（char）：0或'\u0000'
  - 布尔型（boolean）：false
  - 引用数据类型（类/数组/接口）：null
- 局部变量：没有默认初始化值
  - 意味着，在调用局部变量之前，一定要显式赋值
  - 特别的，形参在调用时，我们赋值即可
内存中加载的位置不同
- 属性（非static）：加载到堆空间
- 局部变量：加载到栈空间

对象数组

//打印出三年级的学生信息
//使用冒泡排序对学生成绩排序，并遍历所有学生信息
public class ClassTest {
    public static void main(String[] args){
        //定义对象数组
        Student[] stu = new Student[20];
        //循环对对象数组进行赋值
        for (int i = 0;i < stu.length;i++){
            stu[i] = new Student();
            stu[i].number = i+1;
            stu[i].state = (int)(Math.random()*6+1);
            stu[i].score = (int)(Math.random()*100);
            //打印出三年级的学生信息
            if (stu[i].state == 3){
                //System.out.println("number:"+stu[i].number+"\tstate:"+stu[i].state+"\t\tscore:"+stu[i].score);
                stu[i].info();
            }
        }

        //使用冒泡排序按学生成绩排序
        for (int i = 0;i < stu.length-1;i++){
            for (int j = 0;j < stu.length-i-1;j++){
                if (stu[j].score > stu[j+1].score){
                    Student tmp = stu[j];
                    stu[j] = stu[j+1];
                    stu[j+1] = tmp;
                }
            }
        }

        System.out.println("***************************************************");

        //遍历输出
        for (int i = 0;i < stu.length;i++){
            //System.out.println("number:"+stu[i].number+"\tstate:"+stu[i].state+"\t\tscore:"+stu[i].score);
            stu[i].info();
        }
    }
}

class Student{
    int number;
    int state;
    int score;

    public void info(){
        System.out.println("number:"+number+"\tstate:"+state+"\t\tscore:"+score);
    }
}

//改进，提高封装性
//打印出三年级的学生信息
//使用冒泡排序对学生成绩排序，并遍历所有学生信息
public class ClassTest {
    public static void main(String[] args){
        //定义对象数组
        Student[] stu = new Student[20];
        //循环对对象数组进行赋值
        for (int i = 0;i < stu.length;i++){
            stu[i] = new Student();
            stu[i].number = i+1;
            stu[i].state = (int)(Math.random()*6+1);
            stu[i].score = (int)(Math.random()*100);
        }

        //打印出三年级的学生信息
        ClassTest c1 = new ClassTest();
        c1.searchState(stu,3);

        System.out.println("***************************************************");

        //冒泡排序
        c1.sort(stu);

        //遍历输出
        for (int i = 0;i < stu.length;i++){
            stu[i].info();
        }
    }

    /**
     * @desc   按照年级搜索
     * @author misspower
     * @date   2022/1/20 9:26
     * @param  stu,state
     * @return  
     **/
    public void searchState(Student[] stu,int state){
        for (int i = 0;i < stu.length;i++){
            if (stu[i].state == state){
                stu[i].info();
            }
        }
    }

    /**
     * @desc   冒泡排序
     * @author misspower
     * @date   2022/1/20 9:26
     * @param  stu
     * @return  
     **/
    public void sort(Student[] stu){
        for (int i = 0;i < stu.length-1;i++){
            for (int j = 0;j < stu.length-i-1;j++){
                if (stu[j].score > stu[j+1].score){
                    Student tmp = stu[j];
                    stu[j] = stu[j+1];
                    stu[j+1] = tmp;
                }
            }
        }
    }
}

class Student{
    int number;
    int state;
    int score;

    public void info(){
        System.out.println("number:"+number+"\tstate:"+state+"\t\tscore:"+score);
    }
}

匿名对象

理解：

我们创建的对象没有一个显示的变量名，即为匿名对象。

特征：

匿名对象只能调用一次

public class ClassTest {
    public static void main(String[] args) {
        //二者不是同一个对象
        new Student().info();
        new Student().info();
    }
}

class Student{
    public void info(){
        System.out.println("i'm a student!");
    }
}

public class ClassTest {
    public static void main(String[] args) {
        StudentInfo stu = new StudentInfo();
        stu.show(new Student());
    }
}

class StudentInfo{
    public void show(Student stu){
        stu.showName();
        stu.showSex();
    }
}

class Student{
    public void showName(){
        System.out.println("my name is Tom");
    }
    public void showSex(){
        System.out.println("my sex is male");
    }
}

方法的重载

定义：

在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可

特点：

同名不同参

与返回值无关，只看参数列表，而且参数列表必须不同

可变个数的形参

可变形参必须声明在末尾
方法形参列表中最多声明一个可变形参

public class ClassTest {
    public static void main(String[] args) {
        ClassTest test = new ClassTest();
        test.show("a","b");
    }

    public void show(String ... strs){
        for (String e:strs){
            System.out.println(e);
        }
    }
}

方法参数的值传递机制

形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的值

值传递机制：

参数是基本数据类型：此时实参赋值给方法形参的是真实存储的数据值
参数是引用数据类型：此时实参赋值给方法形参的是实参地址值

//不能实现m和n的交换
public class ClassTest {
    public static void main(String[] args) {
        ClassTest test = new ClassTest();

        int m = 3;
        int n = 4;
        test.swap(m,n);
        System.out.println(m+" "+n);
    }

    public void swap(int i,int j){
        int tmp = i;
        i = j;
        j = tmp;
    }
}

//可以实现交换
public class ClassTest {
    public static void main(String[] args) {
        ClassTest test = new ClassTest();

        int[] arr = new int[]{3,4};
        test.swap(arr,0,1);
        System.out.println(arr[0]+" "+arr[1]);
    }

    public void swap(int[] arr,int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

递归

//f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n)
public class ClassTest {
    public static void main(String[] args) {
        ClassTest test = new ClassTest();
        System.out.println(test.getSum(10));
    }

    public long getSum(int n){
        if (n == 0){
            return 1;
        }else if (n == 1){
            return 4;
        }else{
            return 2 * getSum(n - 1) + getSum(n - 2);
        }
    }
}

//斐波那契数列
//一个数等于前两个数的和
public class ClassTest {
    public static void main(String[] args) {
        ClassTest test = new ClassTest();
        System.out.println(test.getSum(10));
    }

    public long getSum(int n){
        if (n == 1){
            return 1;
        }else if (n == 2){
            return 1;
        }else{
            return getSum(n - 1) + getSum(n - 2);
        }
    }
}

封装性

封装性的体现需要权限修饰符的配合，修饰符可以修饰：内部类、属性、方法、构造器

特别的，类只能使用 缺省/public 修饰

四种权限修饰符：

private：只能在类内使用
缺省（default）
protected：同一个包、不同包的子类
public

public class ClassTest {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        a1.setLegs(2);
        System.out.println(a1.getLegs());
    }
}

class Animal{
    private int legs;
    public void setLegs(int l){
        legs = l;
    }
    public int getLegs(){
        return legs;
    }
}

构造器

构造器（constructor）的作用：

创建对象
初始化属性

说明：

如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
定义构造器的格式：权限修饰符类名(形参列表){}
构造器可以重载
一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

JavaBean

JavaBean是指符合如下标准的Java类：

类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法

this关键字

使用：

this 可以用来修饰：属性、方法、构造器

修饰构造器时注意事项：

构造器的调用必须在构造器的首行
构造器内部只能调用一个构造器

public class ClassTest {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        a1.setLegs(2);
        System.out.println(a1.getLegs());
    }
}

class Animal{
    private int legs;
    public void setLegs(int legs){
        this.legs = legs;
    }
    public int getLegs(){
        return legs;
    }
}

package关键字

为了更好的实现项目中类的管理，提供包的概念

使用package声明类或接口所属的包，声明在源文件的首行

包属于标识符，遵循标识符的命名规范，“见命知意”

每“.”一次，就代表一层文件目录

同一个包下不能命名同名的类或接口

import关键字

导入

在源文件中显式的使用import结构导入指定的包下的类、接口

声明在包声明和类声明之间

如果需要导入多个结构，则并列写出即可

可以使用"xxx.*"的方式

如果使用的类或接口是在java.lang包下定义的，则可以省略import结构

如果在源文件中使用了不同包下的同名的类，则必须至少有一个需要以全类名的方式

使用"xxx.*"方式表明可以使用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，仍需要显示导入

import static：导入指定类或接口中的静态结构

MissPower007

http://time.pings.fun

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 MissPower007 !

Java

文件包含之pearcmd.php的妙用

CTF中遇到的知识点

2021-11-23 Web

CTF

PbootCMS3.1.2前台SQL注入漏洞分析

记录一下自己挖到的CMS漏洞

2022-02-11 Web

SQL注入