公告

JavaSE基础

f0f30996658f45427a3c7ee6d36c24e6

JavaSE基础

1 Java环境配置

1.1 安装JDK

推荐安装JDK1.8（JDK8）广泛使用

打开cmd，输入以下命令，查看是否安装成功

java -version

1.2 配置环境变量

配置环境变量路径：此电脑→属性→高级系统设置→环境变量

Untitled

1.配置JAVA_HOME

配置为JDK的安装路径

323232331

2.配置Path

1121323131

2 基础语法

2.1 Helloworld编写

使用Notepad++编写代码


xxxxxxxxxx
5
1
public class Hello{
2
    public static void main(String[] args){
3
        System.out.print("Hello,world!");
4
    }
5
}

在当前目录下使用CMD对代码进行编译，命令如下：


xxxxxxxxxx
1
1
javac Hello.java

编译完成,生成Hello.class，使用CMD运行，命令如下：


xxxxxxxxxx
1
1
java Hello

2.2 IDEA使用

打开IDEA创建项目

idea1

选择New Project新建项目

idea2

创建好的项目文件

public static void main 联想输入psvm
System.out.prinfln 联想输入sout

快速补全代码

idea3


xxxxxxxxxx
8
1
public class HelloWorld {
2
    public static void main(String[] args) {
3
        //output string "Hello World !"
4
        /*
5
        * output string "Hello World !" */
6
        System.out.println("Hello World !");
7
    }
8
}

2.3 基本知识

接着之前写的Helloworld，解释其中字串的含义：


xxxxxxxxxx
5
1
public class HelloWorld {
2
    public static void main(String[] args){
3
       System.out.println("Hello World"); 
4
    }
5
}

1213133132

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

2.4 注释，标识符，关键字

1)注释


xxxxxxxxxx
11
1
public class HelloWorld {
2
   /* 这是第一个Java程序
3
    * 它将输出 Hello World
4
    * 这是一个多行注释的示例
5
    */
6
    public static void main(String[] args){
7
       // 这是单行注释的示例
8
       /* 这个也是单行注释的示例 */
9
       System.out.println("Hello World"); 
10
    }
11
}

2)Java 关键字

下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。

关键字	类别	说明
private	访问控制	私有
public	访问控制	公有
protected	访问控制	保护
default	访问控制	默认
abstract	类，方法，变量修饰符	声明抽象
class	类，方法，变量修饰符	类
extends	类，方法，变量修饰符	继承

3)Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized

2.5 数据类型

java基本的数据类型如下：

名称	大小
byte	1byte
short	2byte
int	4byte
long	8byte
float	4byte
double	8byte
boolean	1or4byte
char	2byte

2.6 类型转换

数据类型转换必须满足如下规则：

1. 不能对boolean类型进行类型转换。
1. 不能把对象类型转换成不相关类的对象。
1. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
1. 转换过程中可能导致溢出或损失精度，例如：
```
xxxxxxxxxx
2
1
int i =128;
2
byte b = (byte)i;
```
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：


xxxxxxxxxx
2
1
(int)23.7 == 23;
2
(int)-45.89f == -45

2.7 常量

常量定义：常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：


xxxxxxxxxx
1
1
final double PI = 3.1415927;

字面常量：虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

字面量可以赋给任何内置类型的变量。例如：


xxxxxxxxxx
2
1
byte a = 68;
2
char a = 'A'

进制表示：byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用字面量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：


xxxxxxxxxx
3
1
int decimal = 100;
2
int octal = 0144;
3
int hexa =  0x64;

字符串常量：和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：


xxxxxxxxxx
3
1
"Hello World"
2
"two\nlines"
3
"\"This is in quotes\""

Unicode字符：字符串常量和字符常量都可以包含任何Unicode字符。例如：


xxxxxxxxxx
2
1
char a = '\u0001';
2
String a = "\u0001";

2.8 变量

变量声明

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：


xxxxxxxxxx
7
1
type identifier [ = value][, identifier [= value] ...] ;
2
int a, b, c;             // 声明三个int型整数：a、 b、c
3
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
4
byte z = 22;             // 声明并初始化 z
5
String s = "runoob";     // 声明并初始化字符串 s
6
double pi = 3.14159;     // 声明了双精度浮点型变量 pi
7
char x = 'x';            // 声明变量 x 的值是字符 'x'。

变量类型（作用域）

Java语言支持的变量类型有：

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。


xxxxxxxxxx
7
1
public class Variable{
2
    static int allClicks=0;    // 类变量     
3
    String str="hello world";  // 实例变量   
4
    public void method(){
5
        int i =0;              // 局部变量   
6
    }
7
}

局部变量

局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁，通过new创建的分配在堆区；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量（public，private）；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

类变量

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁（类加载）
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

2.9 运算符

算数运算符

关系运算符

位运算符

逻辑运算符

赋值运算符

条件运算符（?:）


xxxxxxxxxx
13
1
public class Test {
2
   public static void main(String[] args){
3
      int a , b;
4
      a = 10;
5
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
6
      b = (a == 1) ? 20 : 30;
7
      System.out.println( "Value of b is : " +  b );
8
 
9
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
10
      b = (a == 10) ? 20 : 30;
11
      System.out.println( "Value of b is : " + b );
12
   }
13
}

Value of b is : 30
Value of b is : 20

2.10 扫描器

扫描器使用：


xxxxxxxxxx
17
1
public class scannerDemo01 {
2
    public static void main(String[] args) {
3
        //創建掃描器對象
4
        Scanner scanner = new Scanner(System.in);
5

6
        System.out.println("使用next方法接受：");
7

8
        //判斷用戶有無輸入字符串
9
        if (scanner.hasNext()){
10
            String str = scanner.next();
11
            System.out.println("輸入内容為："+str);
12
        }
13
        //Io流的類，使用完需要關閉，否則占用資源
14
        scanner.close();
15

16
    }
17
}


xxxxxxxxxx
4
1
scanner.nextLine(); //遇到换行停止读取
2
scanner.next(); //遇到空格和换行停止
3
scanner.nextInt(); //只读取整数
4
scanner.nextFloat(); //只读取小数

3 流程控制

3.1 条件语句

if语句

语法

if 语句的语法如下：


xxxxxxxxxx
4
1
if(布尔表达式)
2
{
3
   //如果布尔表达式为true将执行的语句
4
}

if...else语句

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

语法

if…else 的用法如下：


xxxxxxxxxx
5
1
if(布尔表达式){
2
   //如果布尔表达式的值为true
3
}else{
4
   //如果布尔表达式的值为false
5
}

switch case 语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

语法

switch case 语句语法格式如下：


xxxxxxxxxx
11
1
switch(expression){
2
    case value :
3
       //语句
4
       break; //可选
5
    case value :
6
       //语句
7
       break; //可选
8
    //你可以有任意数量的case语句
9
    default : //可选
10
       //语句
11
}

case中的变量类型可以是： byte、short、int 、 char、String 类型
当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句

3.2 循环语句

while 循环

while是最基本的循环，它的结构为：


xxxxxxxxxx
3
1
while( 布尔表达式 ) {
2
  //循环内容
3
}

do…while 循环

do…while 循环至少会执行一次


xxxxxxxxxx
3
1
do {
2
       //代码语句
3
}while(布尔表达式);

for循环


xxxxxxxxxx
3
1
for(初始化; 布尔表达式; 更新) {
2
    //代码语句
3
}

for 循环（go range关键字）


xxxxxxxxxx
4
1
for(声明语句 : 表达式)
2
{
3
   //代码句子
4
}

例子：


xxxxxxxxxx
16
1
public class Test {
2
   public static void main(String args[]){
3
      int [] numbers = {10, 20, 30, 40, 50};
4
 
5
      for(int x : numbers ){
6
         System.out.print( x );
7
         System.out.print(",");
8
      }
9
      System.out.print("\\n");
10
      String [] names ={"James", "Larry", "Tom", "Lacy"};
11
      for( String name : names ) {
12
         System.out.print( name );
13
         System.out.print(",");
14
      }
15
   }
16
}


xxxxxxxxxx
2
1
10,20,30,40,50,
2
James,Larry,Tom,Lacy,

break 关键字

break 跳出最里层的循环，并且继续执行该循环下面的语句

语法

break 的用法很简单，就是循环结构中的一条语句：


xxxxxxxxxx
1
1
break;

continue 关键字

让程序立刻跳转到下一次循环的迭代

语法

continue 就是循环体中一条简单的语句：


xxxxxxxxxx
1
1
continue;

3.3 流程控制综合

1. 打印九九乘法表


xxxxxxxxxx
11
1
public class forDemo01 {
2
    public static void main(String[] args) {
3
        for(int i = 1; i <= 9; i++){
4
            for(int j=1;j <= 9; j++){
5
                if(j <= i)
6
                    System.out.printf("%d*%d=%d    ",j,i,j*i);
7
            }
8
            System.out.println();
9
        }
10
    }
11
}


xxxxxxxxxx
9
1
1*1=1    
2
1*2=2    2*2=4    
3
1*3=3    2*3=6    3*3=9    
4
1*4=4    2*4=8    3*4=12    4*4=16    
5
1*5=5    2*5=10    3*5=15    4*5=20    5*5=25    
6
1*6=6    2*6=12    3*6=18    4*6=24    5*6=30    6*6=36    
7
1*7=7    2*7=14    3*7=21    4*7=28    5*7=35    6*7=42    7*7=49    
8
1*8=8    2*8=16    3*8=24    4*8=32    5*8=40    6*8=48    7*8=56    8*8=64    
9
1*9=9    2*9=18    3*9=27    4*9=36    5*9=45    6*9=54    7*9=63    8*9=72    9*9=81

2. 打印被5整除的数每行三个


xxxxxxxxxx
16
1
public class forDemo02 {
2
    public static void main(String[] args) {
3
        int i = 1000;
4
        int outCount = 0;
5
        for(int count = 1; count <= i; count++){
6
            if(count%5 == 0){
7
                System.out.printf("%d \t",count);
8
                outCount++;
9
            }
10
            if(outCount == 3){
11
                System.out.println();
12
                outCount = 0;
13
            }
14
        }
15
    }
16
}

3. 打印三角形


xxxxxxxxxx
13
1
public class forDemo03 {
2
    public static void main(String[] args) {
3
        for (int i = 1; i <= 5; i++) {
4
            for (int j = 5; j > i; j--) {
5
                System.out.print(" ");
6
            }
7
            for (int j = 0; j < i*2-1; j++) {
8
                System.out.printf("%d",i);
9
            }
10
            System.out.println();
11
        }
12
    }
13
}

4 数组

4.1 数组创建


xxxxxxxxxx
17
1
public class arrayDemo01 {
2
    /*數組創建*/
3
    public static void main(String[] args) {
4
        int[] nums;
5
        nums = new int[5];
6
        nums[0] = 1;
7
        nums[1] = 2;
8
        nums[2] = 3;
9
        nums[3] = 4;
10
        nums[4] = 5;
11
        int sum = 0;
12
        for (int i = 0; i < nums.length; i++) {
13
            sum += nums[i];
14
        }
15
        System.out.println(sum);
16
    }
17
}

4.2 二维数组


xxxxxxxxxx
7
1
public class arrayDemo02 {
2
    /*二維數組*/
3
    public static void main(String[] args) {
4
        int [][] array = {{1,2},{2,3},{4,5}};
5
        System.out.println(array[0][1]);
6
    }
7
}

4.3 Arrays类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。


xxxxxxxxxx
10
1
public class arrayClassArray {
2
    /*Arrays class*/
3
    public static void main(String[] args) {
4
        int[] a = {1,23,4,6,7,1,432,46,112,111};
5
        System.out.println(a);
6
        System.out.println(Arrays.toString(a));
7
        Arrays.sort(a);
8
        System.out.println(Arrays.toString(a));
9
    }
10
}

4.4 稀疏数组


xxxxxxxxxx
75
1
public class arrayDemo03 {
2
    /*稀疏數組*/
3
    public static void main(String[] args) {
4
        //创建原数组
5
        int[][] array = new int[11][11];
6
        array[1][2] = 1;
7
        array[2][3] = 2;
8

9
        System.out.println("original array");
10
        //输出原数组的值
11
        for (int[] ints : array) {
12
            for (int anInt : ints) {
13
                System.out.print(anInt+"\t");
14
            }
15
            System.out.println();
16
        }
17
        //转换为稀疏数组
18
        System.out.println("----------------------------");
19
        //计算非0的数据总数
20
        int sum = 0;
21
        for (int i = 0; i < 11; i++) {
22
            for (int j = 0; j < 11; j++) {
23
                if (array[i][j] != 0){
24
                    sum++;
25
                }
26
            }
27
        }
28
        
29
        System.out.println("values:" + sum);
30

31
        int[][] rareArray = new int[sum+1][3];
32
        //第一行记录原数组行数，列数，非0的数据总数
33
        rareArray[0][0] = array.length;
34
        rareArray[0][1] = array[0].length;
35
        rareArray[0][2] = sum;
36
        //记录非0的数据坐标
37
        int count = 0;
38
        for (int i = 0; i < array.length; i++) {
39
            for (int j = 0; j < array[i].length; j++) {
40
                if (array[i][j] != 0){
41
                    count++;
42
                    rareArray[count][0] = i;
43
                    rareArray[count][1] = j;
44
                    rareArray[count][2] = array[i][j];
45
                }
46
            }
47
        }
48
        //输出稀疏数组
49
        System.out.println("rare array:");
50
        
51
        for (int i = 0; i < rareArray.length; i++) {
52
            for (int j = 0; j < rareArray[i].length; j++) {
53
                System.out.print(rareArray[i][j]+"\t");
54
            }
55
            System.out.println();
56
        }
57

58
        System.out.println("----------------------------");
59
        //还原稀疏数组
60
        System.out.println("restore array:");
61
        //根据行列数创建数组
62
        int[][] reArray = new int[rareArray[0][0]][rareArray[0][1]];
63
        //根据坐标还原数据
64
        for (int i = 1; i < rareArray.length; i++) {
65
            reArray[rareArray[i][0]][rareArray[i][1]] = rareArray[i][2];
66
        }
67

68
        for (int[] ints : reArray) {
69
            for (int anInt : ints) {
70
                System.out.print(anInt+"\t");
71
            }
72
            System.out.println();
73
        }
74
    }
75
}

4.5 冒泡排序


xxxxxxxxxx
22
1
public class sortDemo01 {
2
    /*冒泡排序*/
3
    public static void main(String[] args) {
4
        int[] a = {1,2,11,33,2,441,21,41,51123};
5
        a = sort(a);
6
        System.out.println(Arrays.toString(a));
7
    }
8

9
    public static int[] sort(int[] array){
10
        int temp = 0;
11
        for (int i = 0; i < array.length-1 ; i++) {
12
            for (int j = 0; j < array.length-i-1; j++) {
13
                if (array[j] > array[j+1]){
14
                    temp = array[j];
15
                    array[j] = array[j+1];
16
                    array[j+1] = temp;
17
                }
18
            }
19
        }
20
        return array;
21
    }
22
}

5 String类

5.1 创建字符串


xxxxxxxxxx
7
1
String s1 = "Runoob";               // String 直接创建
2
String s2 = "Runoob";               // String 直接创建
3
String s3 = s1;                     // 相同引用
4
String s4 = new String("Runoob");   // String 对象创建
5
String s5 = new String("Runoob");   // String 对象创建
6
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
7
String helloString = new String(helloArray);  //用字符串数组创建

5.2 String 方法

字符串长度


xxxxxxxxxx
1
1
string.length();

连接字符串


xxxxxxxxxx
1
1
"Hello," + " world" + "!"

6 方法

6.1 方法创建


xxxxxxxxxx
11
1
public class funcDemo01 {
2
    /*主函數*/
3
    public static void main(String[] args) {
4
        int sum = add(1,1);
5
        System.out.println(sum);
6
    }
7
    /*定義方法*/
8
    public static int add(int a,int b) {
9
        return a+b;
10
    }
11
}

6.2 方法重载

定义同名方法，不同参数进行方法重载


xxxxxxxxxx
22
1
/*方法重載*/
2
public static void main(String[] args) {
3
    int max1 = max(10,20);
4
    double max2 = max(10.0,20.0);
5
    System.out.println(max1+" "+max2);
6
}
7

8
public static int max (int a, int b) {
9
    if (a > b){
10
        return a;
11
    }else {
12
        return b;
13
    }
14
}
15

16
public static double max (double a, double b){
17
    if (a > b){
18
        return a;
19
    }else{
20
        return b;
21
    }
22
}

6.3 命令行传参


xxxxxxxxxx
6
1
/*命令行傳參*/
2
public static void main(String[] args) {
3
    for (int i = 0; i < args.length ; i++) {
4
        System.out.println("args["+ i +"]:"+args[i]);
5
    }
6
}

6.4 可变参数


xxxxxxxxxx
14
1
/*可變參數*/
2
public static void main(String[] args) {
3
    funcDemo04 demo04 = new funcDemo04();
4
    demo04.test(1,2,3,4,5,6);
5
}
6

7
public void test(int... i){
8
    System.out.println(i[0]);
9
    System.out.println(i[1]);
10
    System.out.println(i[2]);
11
    System.out.println(i[3]);
12
    System.out.println(i[4]);
13
    System.out.println(i[5]);
14
}

6.5 递归


xxxxxxxxxx
13
1
/*递归*/
2
public static void main(String[] args) {
3
    funcDemo06 demo06 = new funcDemo06();
4
    System.out.println(demo06.test(5));
5
}
6

7
public static int test(int n){
8
    if (n == 1){
9
        return 1;
10
    }else {
11
        return n*test(n-1);
12
    }
13
}

7 对象与类

7.1 对象和类

基本概念

多态
继承
封装
抽象
类
对象
实例
方法
重载

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

7.2 构造器

构造器（构造方法）分为有参构造，无参构造，不声明构造方法会默认带无参构造，但是创建了有参构造之后就不会自动生成无参构造了，需要手动声明无参构造才能使用


xxxxxxxxxx
19
1
public class Person {
2
    private String name;
3
    private int age;
4
    private char ID;
5
    /*使用构造器賦值*/
6
    //有参构造
7
    public Person(String name){
8
        this.name = name;
9
    }
10
    //无参构造
11
    public Person() {
12

13
    }
14
    //有参构造 重载
15
    public Person(String name, int age) {
16
        this.name = name;
17
        this.age = age;
18
    }
19
}

7.3 创建对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。

下面是一个创建对象的例子：


xxxxxxxxxx
6
1
/*对类进行实例化 创建对象*/
2
student student = new student();
3
student.study();
4

5
Person Zhang = new Person("張三");
6
Person xiao = new Person("小明",11);

7.4 访问对象属性与方法

直接访问对象的属性和方法，方法和属性需要是public或者default属性


xxxxxxxxxx
6
1
class person{
2
    public String name;
3
}
4

5
person person = new person();
6
System.out.println(person.name);

7.5 封装

使用private控制符修饰类属性，通过共有方法来获取私有属性


xxxxxxxxxx
26
1
public class Person {
2
    private String name;
3
    private int age;
4
    private char ID;
5
    /*构造方法*/
6
    public Person(String name){
7
        this.name = name;
8
    }
9

10
    public Person() {
11

12
    }
13

14
    public Person(String name, int age) {
15
        this.name = name;
16
        this.age = age;
17
    }
18
    /*get set方法*/
19
    public String GetName(){
20
        return this.name;
21
    }
22

23
    public int GetAge(){
24
        return this.age;
25
    }
26
}


xxxxxxxxxx
2
1
System.out.println(Zhang.GetName());
2
System.out.println(xiao.GetName() + " " +xiao.GetAge());

7.6 继承

extends关键字


xxxxxxxxxx
5
1
class 父类 {
2
}
3
 
4
class 子类 extends 父类 {
5
}

继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。 java-extends-2020-12-08

继承的特性

子类拥有父类非 private的属性、方法
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
子类可以用自己的方式实现父类的方法(重写)
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。

final关键字

final 关键字声明类可以把类定义为不能继承的

继承测试

Person类：


xxxxxxxxxx
31
1
public class Person {
2
    /*屬性*/
3
    private String name;
4
    private int age;
5
    private char ID;
6
    /*使用構造器賦值*/
7
    public Person(String name, int age) {
8
        this.name = name;
9
        this.age = age;
10
    }
11

12
    public Person(String name){
13
        this.name = name;
14
    }
15

16
    public Person() {
17
        System.out.println("person 无参构造");
18
    }
19

20
    public String GetName(){
21
        return this.name;
22
    }
23

24
    public int GetAge(){
25
        return this.age;
26
    }
27

28
    public void say(){
29
        System.out.println(this.name + "説了一句話");
30
    }
31
}

student类继承 Person


xxxxxxxxxx
18
1
public class student extends Person {
2
    /*方法*/
3
    public student(String name, int age) {
4
        super(name, age);
5
    }
6

7
    public student(String name) {
8
        super(name);
9
    }
10

11
    public student() {
12
        System.out.println("student 无参构造");
13
    }
14

15
    public void study(){
16
        System.out.println(this.GetName() + "在學習");
17
    }
18
}

main：


xxxxxxxxxx
14
1
public static void main(String[] args) {
2
    /*對類進行實例化*/
3
    Person Zhang = new Person("張三");
4
    Person xiao = new Person("小明",11);
5

6
    System.out.println(Zhang.GetName());
7
    System.out.println(xiao.GetName() + " " +xiao.GetAge());
8

9
    student student = new student("小明");
10
    student.say();
11
    student.study();
12

13
    student student1 = new student();
14
}

7.7 多态

多态就是用父类的引用指向子类的对象，子类重写父类的方法

例1：


xxxxxxxxxx
21
1
public class B {
2
    public void test(){
3
        System.out.println("B test");
4
    }
5
}
6

7
public class A extends B{
8
    public void test(){
9
        System.out.println("A test");
10
    }
11
}
12

13
public class app {
14
    public static void main(String[] args) {
15
        A a = new A();
16
        a.test();
17

18
        B b = new A();
19
        b.test();
20
    }
21
}


xxxxxxxxxx
2
1
A test
2
A test

例2：


xxxxxxxxxx
31
1
public class Person {
2
    public void run(){
3
        System.out.println("person run");
4
    }
5
}
6

7
public class Student extends Person{
8
    public void run() {
9
        System.out.println("student run");
10
    }
11

12
    public void eat(){
13
        System.out.println("eat");
14
    }
15
}
16

17
public class Application {
18

19
    public static void main(String[] args) {
20
        Person stu1 = new Student();
21
        Student stu2 = new Student();
22

23
        stu1.run();
24
        stu2.run();
25

26
        System.out.println(stu1 instanceof Student);
27
        System.out.println(stu2 instanceof Student);
28
        //需要进行强制类型转换才能使用子类的方法
29
        ((Student)stu1).eat();
30
    }
31
}


xxxxxxxxxx
5
1
student run
2
student run
3
true
4
true
5
eat

7.8 抽象类

abstract关键字

声明了abstract的方法只能声明，实现只能在子类中重写实现

abstract方法只能在abstract抽象类中定义


xxxxxxxxxx
13
1
public abstract class Action {
2
    public abstract void Do();
3
    public void say(){
4
        System.out.println("say");
5
    }
6
}
7

8
public class A extends Action {
9
    @Override
10
    public void Do() {
11
        System.out.println("Do");
12
    }
13
}

7.9 接口

接口可以实现双继承，模板中的方法只能声明，不能实现

接口创建


xxxxxxxxxx
10
1
public interface UserService {
2
    public void Add();
3
    public void Del();
4
    public void Mod();
5
    public void Query();
6
}
7

8
public interface TimeService {
9
    public void Timer();
10
}

implements关键字

implements关键字用来实现接口


xxxxxxxxxx
27
1
public class UserServiceImpl implements UserService,TimeService {
2
    @Override
3
    public void Add() {
4
        System.out.println("add user");
5
    }
6

7
    @Override
8
    public void Del() {
9
        System.out.println("delete user");
10
    }
11

12
    @Override
13
    public void Mod() {
14
        System.out.println("modify user");
15
    }
16

17
    @Override
18
    public void Query() {
19
        System.out.println("query user");
20
    }
21

22
    @Override
23
    public void Timer() {
24
        Date d = new Date(2021,11,1);
25
        System.out.println(d);
26
    }
27
}

8 异常处理

8.1 异常概述

三种类型的异常：

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

Exception 类的层次

exception-hierarchy

8.2 捕获异常

try catch

IDEA：Crtl+Alt+T快速创建代码块

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：


xxxxxxxxxx
7
1
try
2
{
3
   // 程序代码
4
}catch(ExceptionName e1)
5
{
6
   //Catch 块
7
}

多重捕获块

一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

把小异类型常在前大异常类型在后


xxxxxxxxxx
9
1
try{   
2
    // 程序代码 
3
}catch(异常类型1 异常的变量名1){  
4
    // 程序代码 
5
}catch(异常类型2 异常的变量名2){  
6
    // 程序代码 
7
}catch(异常类型3 异常的变量名3){  
8
    // 程序代码 
9
}

finally关键字

finally 代码块中的代码总会被执行，在 finally 代码块中，可以运行清理类型等收尾善后性质的语句


xxxxxxxxxx
16
1
public static void main(String[] args) {
2
    int a = 1;
3
    int b = 0;
4

5
    try {
6
        System.out.println(a/b);
7
    }catch (Error e){
8
        System.out.println("Error");
9
    }catch (Exception e){
10
        System.out.println("Exception");
11
    }catch (Throwable e){
12
        System.out.println("Throwable");
13
    }finally {
14
        System.out.println("异常处理");
15
    }
16
}

8.3 抛出异常

throws/throw 关键字

throw 关键字：主动抛出异常


xxxxxxxxxx
9
1
try {
2
    if(b == 0){
3
        throw new ArithmeticException();
4
    }
5
    System.out.println(a/b);
6
} catch (Exception e) {
7
    System.out.println("b不能为0");
8
    e.printStackTrace();
9
}

抛出的异常需要被捕获或者用throws关键字抛出此方法，在方法外部捕获异常

一个方法可以抛出多种异常


xxxxxxxxxx
1
public static void main(String[] args) {
2
    try {
3
        new Test().test(1,0);
4
    } catch (ArithmeticException e) {
5
        System.out.println("b不能为0");
6
        e.printStackTrace();
7
    }
8

9
}
10

11
public void test(int a, int b) throws ArithmeticException{
12
    if(b == 0){
13
        throw new ArithmeticException();
14
    }
15
}

8.4 自定义异常

通过继承Exception类来自定义异常，自定义的异常可以写自己的方法，重写toString方法打印异常信息，定义构造方法来记录异常的信息

MyException:


x
1
public class MyException extends Exception{
2
    /*传递数字>10*/
3
    private int detail;
4

5
    public MyException(int a){
6
        this.detail = a;
7
    }
8
    /*toString*/
9
    @Override
10
    public String toString() {
11
        return "MyException{" +
12
                "detail=" + detail +
13
                '}';
14
    }
15
}

main & test:


xxxxxxxxxx
1
static void test(int a) throws MyException{
2
    System.out.println("传递的参数为：" + a);
3
    if(a>10){
4
        throw new MyException(a);
5
    }
6

7
    System.out.println("OK");
8
}
9

10
public static void main(String[] args) {
11
    try {
12
        test(1);
13
    } catch (MyException e) {
14
        System.out.println("MyException->" + e);
15
    }
16

17
    try {
18
        test(11);
19
    } catch (MyException e) {
20
        System.out.println("MyException->" + e);
21
    }
22
}

结果：


xxxxxxxxxx
1
1
传递的参数为：1
2
OK
3
传递的参数为：11
4
MyException->MyException{detail=11}

打印堆栈信息就会调用重写的toString方法，打印错误信息

posted on 2021-12-01 22:52 Egoistic_Flowers 阅读(32) 评论(0) 编辑收藏举报

刷新页面返回顶部