2023.10(u盘刻录iso)主机，vmware，virtualbox安装linux/ubuntu/kali-CFANZ编程社区

一.类与对象

思维导图概览：

1. 一个程序就是一个世界，世界（程序）有很多事物（属性，行为）

2. 什么是类？什么是对象？类与对象的关系是什么？

3. 类和对象的区别与联系

4. 一个小case快速了解类和对象

public class Test {
    public static void main(String[] args) {
        Person person = new Person(); 
        //使用Person类，new Person()即是向类申请一个对象，申请的对象把它赋给person， person是一个对象
        //即person是Person的实例化  
    }
}


//Person类，一个类，Person是自定义类型，可以理解为C语言中的结构体
class Person() {
    int age; //成员变量/属性
    String name; //成员变量/属性
}

5. 对象在内存中的存在形式

6. 属性/成员变量/字段

class Animal {
    int age;
    String name;
    //以上的这些就叫做成员变量/属性
}

权限修饰符 属性类型 属性名;
//注意：一般的局部变量我们需要给它赋初值，而成员变量则不需要赋予初值
//权限修饰符：public > protected > 默认 > private
//属性类型：八大类型，也可以是引用类型

属性类型	默认值
boolean	false
byte, short, int, long	0
char	'\u0000' [十进制:0]
float, double	0.0

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println(cat.age);
        System.out.println(cat.c);
        System.out.println(cat.f);
        System.out.println(cat.b);
    }
}

class Cat() {
    int age; //默认为0
    char c; //默认为0
    double f; //默认为0.0
    boolean b; //默认为false
}

7. 创建对象

public class Test {
    public static void main(String[] args) {
        //先声明后创建对象
        Person p;
        p = new Person();
        
        //直接创建
        Person person = new Person();
    }
}

class Person {
    
}

8. 访问属性

public class Test {
    public static void main(String[] args) {
        //直接创建对象
        Person p1 = new Person();
        
        //访问成员变量/属性
        p1.name = "jack";
        p1.age = 18;
        Person p2 = p1;                                                            
    }
}

class Person {
    //成员变量
    String name;
    int age;
}

9. 类和对象的内存分布机制

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        //new Person --> 在方法区种先加载Person类信息（属性和方法信息，只会加载一次
        //然后在堆中分配空间，进行默认初始化
        //把地址赋给p，p指向在堆中开辟的空间
        
        //把Person中的属性修改
        p.name = "jack";
        p.age = 10;
    }
}

class Person() {
    String name;
    int age;
}

10. 成员变量与局部变量的区别

区别点	局部变量	成员变量
类中位置不同	方法内部/方法声明上	类中方法外
内存中位置不同	栈内存	堆内存
生命周期不同	随着方法的调用而存在, 方法调用完毕后销毁	随着对象的存在而存在, 随着对象的销毁而销毁
初始化不同	没有默认初始化,必须先定义,后使用	有默认初始化

11. 思考以下代码输出什么？

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "smith";
        p1.age = 18;
        
        Person p2;
        p2 = p1;
        System.out.println(p2.name);//?输出什么？
        p2.age = 20;
        p2 = null;
        System.out.println(p1.age);//?输出什么？
        System.out.println(p2.age);//?输出什么？
    }
}

class Person {
    String name;
    int age;
}

//答案：smith  20  出现异常

二.成员方法

思维导图概览：

1. 什么是成员方法？

2. 一个小case快速了解成员方法

public class Test {
    public static void main(String[] args) {
        Perosn p = new Person();
        //调用成员方法
        int res = p.getSum(10,20);
    }
}

class Person {
    String name;
    int age;
    
    //成员方法
    public int getSum(int num1, int num2) {
        return num1 + num2;
    }
}

3.方法调用总结

4. 成员方法的好处

5. 成员方法的定义

class Aniaml {
    
    public void print() {
        System.out.println("动物爱睡觉~~");    
    }
    
    //分析
    //成员方法由：访问修饰符 返回类型 方法名（形参列表1, 形参列表2, ……){//方法体组成
    //    语句;
    //    return 返回值;
    //}
}

6. 成员方法的注意事项和细节讨论

class Teacher {
    public int getAge(String name, int age) {
        //return name,age; //错误，只能有一个返回值  
    }
    
    public void print() {
        //无返回值    
    }
}

class People {
    //返回int类型
    public int print(int age){}
    
    //返回double类型
    public double sum(){}
    
    //返回String类型,String是引用类型
    public String getString() {}
}

class People {
    public int getAge(int age) {
        return age;//必须返回相符合的类型    
    }
}

class People {
    public void print() {
        //return age; //错误，不能返回值 
        return; //正确   
    }
}

public class Test {
    public static void main(Stirng[] args) {
        People p = new People();
        p.printNum(10,20);//实参和形参的数据类型要一致或兼容
        //10,20 --> 实参
    }
}

class People {
    String name;
    int age;
    
    //1.一个方法可以有0个参数或多个参数，若是多个参数，中间用逗号隔开
    //0个参数
    public void print() {
            
    }
    
    //多个参数，中间用逗号隔开
    public void set(int num1, int num2, int num3){}
    
    //2. 参数类型可以是任意类型，包含基本数据类型，但是传进方法中的数据和方法中的参数类型要相同或兼容
    public void printNum(int num1,int num2){}
    //int num1, int num2 ---> 形参
}

7. 方法调用细节

public class Test {
    public static void main(String[] args) {
        People p = new People();
        //调用本类中的方法：直接调用
        set();
        //调用其他类中的方法:通过对象名调用
        p.print();                            
    }
    
    public static void set() {            
    }
}

class People {
    public void print() {}
}

三.成员方法的传参机制

1. 基本数据类型的传参机制

public class Test {
    public static void main(String[] args) {
        Test test = new Test();    
        int num1 = 10;
        int num2 = 20;
        test.swap(num1,num2);
        
        System.out.println("num1 = " + num1 + " num2 = " + num2);
        //10 , 20
        //形参的改变不会影响实参   ---- > 值传递
    }
    
    public void swap(int num1, int num2) {
        int temp = num1;
        num1 = num2;
        num2 = temp;    
        System.out.println("num1 = " + num1 + " num2 = " + num2);
        //20 ,10
    }
}

2. 引用数据类型的传参机制

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        int[] arr = {1, 2, 3, 4, 5};
        
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");// 1 2 3 4 5                
        }  
        modifyArr(arr);
        
        Person p = new Person();
        p.name = "jack";
        p.age = 18;
        test.print(p); 
        System.out.println(p.age);//20
        System.out.println(p.name);//smith                                       
        //得出结论，若是址传递，则修改形参的值会影响实参    
    }
    
    public void modifyArr(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            arr[i] = 0;                    
        }    
        
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t"); // 0 0 0 0 0                   
        }
    }
    
    public void print(Person p) {
        p.name = "smith";
        p.age = 20;
    }
}


class Person {
    String name;
    int age;
}

3. 思考以下的问题

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        B b = new B();

        b.name = "jack";
        b.age = 10;

        test.judge(b);

        System.out.println(b.age);//20

    }

    public void judge(B b) {
        //b.age = 20;
        //b =null;
        b = new B();
        b.age = 10000;
        System.out.println(b.age);//10000
    }
}

class B {
    String name;
    int age;
}

4. 成员方法的返回类型是引用类型

public class Test2 {
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        B b = new B();

        b.name = "jack";
        b.age = 10;

        b = test2.judge(b);;

        System.out.println(b.age);//? ---> 18

    }

    //返回对象的类型 ---> 引用类型
    public B judge(B b) {
        b.age = 18;
        b.name = "jerry";
        return b;
    }
}

class B {
    String name;
    int age;
}

四.方法递归调用

思维导图概览：

1. 什么是方法递归？

2. 递归能解决什么问题？

3. 一个小case快速了解递归

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        int n = 10;
        int getFac = test.fac(n); 
        System.out.println(getFac);
    }
    
    public int fac(int n) {
        if(n == 1) {
            return 1;        
        } else {
            return n * fac(n - 1);        
        }                
    }
}

4. 递归的重要规则

五.方法重载

思维导图概览：

1. 什么是方法重载？

2. 方法重载的好处

3. 一个小case快速了解方法重载

public class Test() {
    public static void main(String[] args) {
        Test test = new Test();
        test.print();
        test.print(10,20);
        test.print(10,20,30);    
    }
    public void print() {
        System.out.println("啥也没有~~");   
    }
    public void print(int num1, int num2) {
        System.out.println("num1 = " + num1 + " num2 = " + num2);   
    }
    
    public void print(int num1, int num2, int num3) {
        System.out.println("num1 = " + num1 + " num2 = " + num2 + " num3 = " + num3);   
    }
}

4. 方法重载的注意事项和细节

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        test.getSum();
        System.out.println(test.getSum(10,20));            
    }
    
    //形参列表不同，返回类型无要求
    public void getSum() {
        System.out.println("啥也没有哦~~");    
    }
    
    public int getSum(int num1, int num2) {
        return num1 + num2;    
    }
}

六.可变参数

思维导图概览：

1. 概念：Java中允许同一个类中多个同名同功能但参数不同的方法，封装成一个方法，就可以通过可变参数实现

2. 语法

3. 一个小case快速了解可变参数

public class DemoOne {
    public static void main(String[] args) {
        DemoOne one = new DemoOne();
        int num1 = 20;
        int num2 = 30;
        int num3 = 40;

        //以下的三个的方法名相同，形参列表不同
        System.out.println(one.getSum(num1));
        System.out.println(one.getSum(num1,num2));
        System.out.println(one.getSum(num1,num2,num3));

    }

    public int getSum(int... arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}

4. 可变参数的注意事项和细节

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        //可变参数为0个
        test.print(); 
        //可变参数为多个
        test.print("jack","marry","jerry","tom","smith","maria");                   
    }
    
    public void print(String... arr) {
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");        
        }    
    }
}

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
        test.printArr(arr);
    }
    public void printArr(int... num) {
        for(int i = 0; i< num.length; i++) {
            System.out.print(num[i] + "\t");        
        }    
    }
}

public class Test {
    public static void main(String[] args) {
           
    }
    
    //错误代码，可变参数必须放在最后一个
    //public void show(int... arr, int x){} 

    //正确代码
    public void show(int x, int... arr){}
}

public class Test {
    public static void main(String[] args) {
           
    }
    
    //错误代码：一个形参列表中只能出现一个可变参数
    //public void printArr(int... arr1, int... arr2) {} 
}

七.作用域

思维导图概览：

1. 基本了解

2. 一个小case快速了解全局变量和局部变量

//一个小case了解什么是全局变量（属性）和局部变量
public class Test {
    int age;//全局变量/属性/成员变量 ---> 可直接使用，有默认值：0
    double num; //默认值：0.0
    
    public static void main(String[] args) {
        Test test = new Test();
        //全局变量可以直接使用，无需赋值
        System.out.println(test.age); //0
        System.out.println(test.num); //0.0
        
        test.printAge();
    }
    
    public void printAge() {
        int age; //局部变量，必须赋值才能使用
        //System.out.println(age); //程序报错，因为局部变量要赋值才能使用
        age = 18;
        System.out.println(age); //18            
    }
}

3. 作用域的注意事项和细节

//属性和局部变量可以重名，访问时遵循就近原则
public class Test {
    int age = 10;
    
    public static void main(String[] args) {
        Test test = new Test();
        int age = 20;
        System.out.println(age); //20 --> 就近原则   
        test.printAge();         
    }
    public void printAge() {
        System.out.println(age); // 10
    }
}1

public class Test {
    public static void main(String[] args) {
        //同一个作用域中（可以理解为在同一个方法中），两个局部变量不能重名
        int age = 20;
        int age = 30;    
    }
}

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        //方法中的局部变量：伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁
        test.show();
        
        //属性（成员变量/全局变量）：伴随着对象的创建而创建，伴随着对象的销毁而销毁
        Animal dog = new Animal();
        dog.age = 10;
        System.out.println(dog.age); // 10      
    }
    
    public void show() {
        String name = "Tiger"; //局部变量
        System.out.println(name); // Tiger 
    }
}

class Animal {
    int age = 10;
}

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        //num是局部变量，只能在main方法中使用
        int num = 20;

        //Animal中的age被其他类使用
        Animal a = new Animal();
        a.age = 30;
        System.out.println(a.age); //30
    }
}

class Animal {
    int age = 10;

    //1. 全局变量age被本类使用
    public void getAge() {
        age = 40;
    }
}

public class Test {
    public int age = 30; //全局变量可以加访问修饰符
     
    public static void main(String[] args) {
        //public int age = 20; //局部变量不能使用访问修饰符                
    }
}

八.构造方法/构造器

思维导图概览：

1. 构造器了解

2. 基本语法

修饰符 方法名(形参列表){
    方法体;
}
//1.修饰符可以是默认，也可以是public,protected,private
//2.构造器不能有返回值，也不能写void
//3.方法名必须和类名相同
//4.参数列表和成员方法一样的规则
//5.构造器的调用，由系统来完成

3. 一个小case快速了解构造器

public class Test {
    public class Test {
    public static void main(String[] args) {
        //"smith", 80 -- > 是对类进行初始化
        Animal animal = new Animal("smith", 80);

        System.out.println(animal.name); //smith
        System.out.println(animal.age); //80
    }
}

class Animal {
    String name;
    int age;

    //注意:1.构造器不能有返回值，也不能写void
    //2.构造器的名称必须和类名一致
    //3.String n, int a是形参列表
    public Animal(String n, int a) {
        name = n;
        age = a;
    }
}

4. 构造器的注意事项和细节

class Demo {
    //无参构造器：构造器名（Demo),类名（Demo)
    public Demo() {}
    //一个参数构造器：构造器名（Demo),类名（Demo)
    public Demo(int num) {}
    //多个参数构造器：构造器名（Demo),类名（Demo)
    public Demo(int num1, int num2, int num3.....) {}
    
    //注意：从上面看出我们的构造器名和类名必须相同
    //注意：构造器中我们不能给予返回值，如果给予返回值，那就不是构造器,导致程序崩溃
    //public void Demo() {} //程序错误
}

public class Test {
    public static void main(String[] args) {
        //"smith", 80 -- > 是对类进行初始化
        Animal animal = new Animal("smith", 80);

        System.out.println(animal.name); //smith
        System.out.println(animal.age); //80
    }
}

class Animal {
    String name;
    int age;

    //使用这个构造器后，可以看出本类中的name,age均被初始化
    public Animal(String n, int a) {
        name = n;
        age = a;
    }
}

public class Test {
    public static void main(String[] args) {
        //在创建Animal对象的时候，系统默认调用Animal的构造器
        Animal animal = new Animal();
        //发现Animal类中无给定构造器，系统会自动的给类生成一个默认的无参构造器
    }
}

class Animal {
    String name;
    int age;
    
    //系统发现Animal类中无给定构造器，给定默认构造器
    // public Animal(){}
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal("jack", 30);
    }
}

class Animal {
    String name;
    int age;
    
    //我们写出这个构造器的时候，系统的原先的无参构造器被覆盖了，若是还想使用，则显示定义
    public Animal(String n, int a) {
        name = n;
        age = a;    
    }
    
    //显示定义无参构造器
    public Animal() {}
}

九.对象的创建流程

思维导图概览：

public class Test {
    public static void main(String[] args) {
        Person p = new Person("jack", 18);   
    }
}

class Person {
    //成员变量
    int age;
    String name;
    //构造器
    Person(String n, int a) {
        name = n;
        age = a;    
    }
}

//流程分析
//1.在方法区中加载Person类信息，只会加载一次
//2.在堆中分配空间（地址）
//3.完成对象的初始化、构造器的初始化（age = 0, name = null)
//4.对象在堆中的地址，返回给p（p是对象名，也可以理解是对象的引用）

十.this关键字

思维导图概览：

1. 什么是this关键字？

2. 一个小case快速了解this

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal("Tiger",10);
        animal.print();
    }
}

class Animal {
    String name;
    int age;
    
    public Animal(String name, int age) {
        //this.name代表当前对象(animal)的age
        this.name = name;
        this.age = age;    
    }
    
    public void print() {
        //当中的this.age和this.name都代表当前对象（animal)的name和age
        System.out.println(this.name + "已经" + this.age + "岁了");    
    }
}

3. this的注意事项和细节

public class Test {
    public static void main(String[] args) {
        Person p = new Person("jack", 30);

    }
}

class Person {
    String name;
    int age;

    public Person() {
    }

    public Person(String name, int age) {
        //使用this访问本类的另外一个构造器
        this();
        this.name = name;
        this.age = age;
    }

    public void print() {
        //使用this访问本类的属性
        System.out.println(this.name + this.age + "岁了~~");
    }

    public void getPrint() {
        //使用this访问本类中的方法
        this.print();
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal("Tiger",10);
    }
}

class Animal {
    String name;
    int age;
    
    public Animal(String name, int age) {
        //这样的话我们无法区分那个是形参（局部变量），那个是Animal的name和age
        name = name;
        age = age;   
        //我们使用this来区分区别变量和全局变量
        this.name = name;
        this.age = age;          
    }
}

class Person {
    String id;
    int age;
    
    public Person(){}
    
    public Person(String id, int age) {
        this();//访问另外一个构造器，this必须放在第一句
    }
}

class Animal {
    String name;
    int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;    
    }
    
    //this.age = 18;//错误，this不能在外部（构造器外，方法外）使用
    
    public void print() {
        this.age = 18; //对            
    }
}

十一.权限修饰符

思维导图概览：

1. 权限修饰符了解

2. 权限修饰符的访问范围

访问权限修饰符	同类	同包	子类	不同包
public	√	√	√	√
protected	√	√	√	×
默认	√	√	×	×
private	√	×	×	×

3. 权限修饰符的注意事项和细节

4. 一个小case快速了解权限修饰符

//Person类是默认类
class Person {
    public int num; //公开
    protected char sex; //受保护
    int age; //默认
    private String name; //私有
    
    //公开的构造器
    public Person() {}
    //默认的构造器
    Person() {}
    ……
    
    //公开的方法
    public void print() {}
    //私有的方法
    private void print() {}
}