面向对象基础 - acan的个人博客

面向对象基础#

递归#

递归的意思就是函数自己调用自己

示例：

1
public class Queen {
2
    public static void main(String[] args) {
3
        int[][] board = new int[8][8];
4
        T t = new T();
5
        for(int i=0;i<8;i++) {
6
            for (int j = 0; j < 8; j++) {
7
                board[i][j] = 0;
8
            }
9
        }
10
        t.placeQueen(board,0);
11
    }
12
}
13
class T{
14
    int[] result = new int[8];
15
    public void placeQueen(int[][] board,int m){
16
        if(m==8){
17
            for(int i=0;i<8;i++){
18

19
                System.out.print(result[i] + 1);
20

21
            }
22
            System.out.println();
23
        }
24
        else{
25
            for(int i=0;i<8;i++){
26
                if(isSafe(board,m,i)){
27
                    board[m][i]=1;
28
                    result[m]=i;
29
                    placeQueen(board,m+1);
30
                }
31
                board[m][i]=0;
32
                result[m]=0;
33
            }
34
        }
35
        }
36
        public boolean isSafe(int[][] board,int row,int col) {
37
            for (int i = 0; i < row; i++) {
38
                if (board[i][col] == 1) {
39
                    return false;
40
                }
41
            }
42
            int i = row - 1, j = col - 1;
43
            while (i >= 0 && j >= 0) {
44
                if (board[i][j] == 1) {
45
                    return false;
46
                }
47
                i--;
48
                j--;
49
            }
50
            i = row - 1;
51
            j = col + 1;
52
            while (i >= 0 && j < 8) {
53
                if (board[i][j] == 1) {
54
                    return false;
55
                }
56
                i--;
57
                j++;
58
            }
59
            return true;
60
        }
61
    }

方法的重载#

定义：改变函数的参数列表，其他没有要求

例子:

1
  public void nums(int a,int b){}
2
  public void nums(double a, double b)

可变参数#

就是方法的重载，但是参数只有个数不同。类型相同

1
public void nums(int ... num)//语法，传进去的参数相当于一个数组

细节

可变参数的实参个数可以是零或者多个
可变参数的实质是数组
可变参数可以和其他参数一起放在形参列表中，但是必须只有一个可变参数并且可变参数在最后面

作用域#

属性和局部变量可以重名，访问时遵循就近原则
同一个作用域中不能重名
生命周期都是作用域创建开始，作用域结束就死亡
属性可以加修饰符，局部变量不能加

具体看菜鸟

构造器#

语法

[修饰符] 方法名（参数）{}

使用方法

构造器的修饰符可以默认
构造器没有返回值
方法名必须和类名一样

例子

1
class Person {
2
    private String name;
3
    private int age;
4
    private String gender;
5

6
    public Person(String name, int age, String gender) {
7
        this.name = name;
8
        this.age = age;
9
        this.gender = gender;
10
    }
11

12

13
}
14
//调用
15
Person p1 = new Person("Smith",18,"男");

作用

构造器使得在创建类的时候可以直接指定属性的值

细节

一个类可以写多个构造器，即构造器重载
构造器是完成对象的初始化，不是创建对象
在创建对象的时候，系统自动的调用该类的构造方法
如果没有定义构造方法，系统会自动给类生成一个默认无参构造方法，比如Person(){}
- 一旦定义了自己的构造器，默认的构造器就覆盖了

对象创建的流程分析#

在方法区加载类
在堆里初始化属性
调用构造器函数，重新赋值（引用类型的值会放在常量区）
在栈里创建对象的引用（对象名），指向这个类

this关键字#

通过this.name这样就可以在成员变量和局部变量相同时，使用this.来访问成员的属性哪一个对象调用了，this就代表了哪个对象在堆中被创建的对象里，有一个隐藏属性this,this的值就是对象的内存位置

细节

this关键字可以用来访问本类的属性，方法，构造器
this用于区分当前类的属性和局部变量
访问成员方法的语法：this.方法名（参数列表）;
访问构造器语法(参数列表);注意只能在构造器中使用，并且只能在构造器第一行（即只能在构造器中调用构造器）
this不能再类定义的外部使用，只能在类定义的方法中使用