Java基础-面向对象(一)

一、类和对象

类是对一类事物的描述,是抽象的、概念上的定义

对象时实际存在的该类事物的每一个个体,也称为实例

二、类的成员

  1. 属性:类中的成员变量
  2. 行为:类中的成员方法
  3. 构造器
  4. 代码块
  5. 内部类

三、类和对象的创建

1. 使用步骤

  1. 创建类:设计类的成员
  2. 创建类的对象
  3. 通过对象.属性对象.方法调用对象的结构
package com.example.www;

public class PersonTest {
    public static void main(String[] args) {
        // 创建Person类的对象(实例化一个类)
        Person p1 = new Person();
        // 调用对象的属性 对象.属性
        p1.name = "Tom";
        System.out.println(p1.name);
        // 调用对象的方法 对象.方法
        p1.eat();
        p1.talk("Chinese");

    }
}


// 类的创建
class Person {
    // 属性
    String name;
    int age;
    // 方法
    public void eat(){
        System.out.println("eat...");
    }
    public void talk(String language){
        System.out.println(language);
    }
}

如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性(非static的)。

2. 匿名对象

  1. 创建的对象没有显式的赋值给一个变量

  2. 只能调用一次

public class PhoneTest {
    public static void main(String[] args) {
        new Phone().sendMsg();
        new Phone().playGame();
        // 这个两个不同的对象
    }
}

class Phone{
    public void sendMsg(){
        System.out.println("发短信");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
}

四、属性

属性和局部变量的区别:

相同点:

  1. 定义变量的格式:数据类型 变量名 = 变量值
  2. 先声明后使用
  3. 变量都有其对应的作用域

不同点:

  1. 在类中声明的位置不同
    1. 属性:直接定义在类的一对{}
    2. 局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
  2. 关于权限修饰符的不同
    1. 属性:可以在声明属性时,指明其权限。常用的权限修饰符:private、public、缺省、protected。
    2. 局部变量:不可以使用权限修饰符。
  3. 默认初始化值
    1. 属性:根据其类型,都有默认初始化值
    2. 局部变量:没有默认初始化值,在调用局部变量之前一定要显式赋值。
  4. 在内存中加载的位置
    1. 属性:加载到堆空间中(非static)
    2. 局部变量:加载到栈空间中

五、方法

方法:描述类应该具有的功能。

1. 方法的声明

权限修饰符 返回值类型 方法名(形参列表){
    方法体;
}
  1. 权限修饰符(4种):private、public、缺省、protected
  2. 返回值
    1. 如果方法有返回值,则必须在方法声明时指定返回值类型,同时方法中需要使用return关键字来返回指定类型的变量或常量。
    2. 如果方法没有返回值,则方法声明时使用void来表示。通常在没有返回值的方法中,就不能使用return关键字,如果使用的话只能使用return;来表示此方法结束。
  3. 方法名:属于标识符,遵循标识符的规则和规范。
  4. 形参列表:方法可以声明0个、1个或多个形参。数据类型1 形参1, 数据类型2 形参2...
  5. 方法体:方法功能的实现

2.return关键字

  1. 使用范围:使用在方法体中
  2. 作用:
    1. 结束方法
    2. 针对于有返回值类型的方法,使用return 数据返回所要的数据。
  3. return关键字后面不可以声明执行语句

3. 方法的使用

  1. 方法在使用中,可以调用当前类的属性或方法
  2. 方法中不能定义方法

4. 方法重载

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

与返回值类型无关,只看参数列表,且参数列表必须不同,调用时,根据方法参数列表的不同来区别。

判断方法是否重载,和方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。

5. 可变个数的形参

允许直接定义能和多个实参向匹配的形参,从而可以用一种更简单的方式来传递个数可变的实参。

格式:数据类型 ... 变量名

当调用可变个数形参的方法时,传入的参数个数可以是0个,1个或多个。

可变个数形参的方法与本类中方法名相同、形参不同的方法之间构成重载。

可变个数形参在方法的形参中,必须声明在末尾。

可变个数形参在方法的形参中,最多只能声明一个可变形参。

public class MethodArgsTest {
    public static void main(String[] args) {
        MethodArgsTest test = new MethodArgsTest();
        test.show("Hello");
        test.show("Hello", "World");
//        test.show(new String[]{"Hello", "World"});
    }
//    public void show(String[] strs) {
    public void show(String ... strs){
        System.out.println(strs);
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    }
}

6. 方法参数的值传递机制

Java中方法的参数传递方式只有一种:值传递。即将实际参数值的副本传入方法内,而参数本身不受影响。

  1. 形参是基本数据类型,将实参基本数据类型变量的"数据值"传递给形参
  2. 形参是引用数据类型,将实参引用数据类型变量的"地址值"传递给形参

6.1 方法中变量的赋值:

  1. 如果变量是基本数据类型,此时赋值的是变量所保存的数据值

  2. 如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。

public class ValueTransferTest {
    public static void main(String[] args) {
        int m = 10;
        int n = m;
        System.out.println("m = " + m + ", n = " + n); // m = 10, n = 10
        n = 20;
        System.out.println("m = " + m + ", n = " + n); // m = 10, n = 20
        User user1 = new User();
        user1.name = "Tom";
        User user2 = user1; // user1和user2的地址值相同
        System.out.println("user1.name = " + user1.name + ", user2.name = " + user2.name); // user1.name = Tom, user2.name = Tom
        user2.name = "Jerry";
        System.out.println("user1.name = " + user1.name + ", user2.name = " + user2.name); // user1.name = Jerry, user2.name = Jerry
    }
}

class User{
    String name;
}

6.2 方法的形参值传递机制

  1. 形参:方法定义时,声明在小括号内的参数
  2. 实参:方法调用时实际传递给形参的值。

值传递机制

  1. 如果参数是基本数据类型,此时实参赋给形参的是实参真实存储的数据值。
  2. 如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值。

例:参数是基本数据类型

public class ValueTransferTest {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;

        ValueTransferTest test = new ValueTransferTest();
        test.swap(m, n);

        System.out.println("m = " + m + ", n = " + n); // m = 10, n = 20

    }

    public void swap(int m, int n){
        int tmp = m;
        m = n;
        n = tmp;
    }
}

例:参数是引用数据类型

public class ValueTransferTest {
    public static void main(String[] args) {

        Data data = new Data();
        data.m = 10;
        data.n = 20;
        
        ValueTransferTest test = new ValueTransferTest();
        test.swap(data);
        System.out.println("m = " + data.m + ", n = " + data.n); // m = 20, n = 10
    }
    public void swap(Data data){
        int tmp = data.m;
        data.m = data.n;
        data.n = tmp;
    }
}

class Data{
    int m;
    int n;
}

7. 递归

1. 递归求和

public class RecursionTest {
    public static void main(String[] args) {
        int sum = new RecursionTest().getSum(100);
        System.out.println(sum);
    }
    public int getSum(int n) {
        if (n == 1){
            return 1;
        }else{
            return n + getSum(n-1);
        }
    }
}

2. 斐波那契数列

public class FibonacciTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            long num = fibanacci(i);
            System.out.print(num + " ");
        }
    }
    public static long fibanacci(long number) {
        if (number == 0 || number == 1){
            return number;
        }else{
            return fibanacci(number -1 ) + fibanacci(number - 2);
        }
    }
}

3. 汉诺塔

// https://blog.csdn.net/ljmingcom304/article/details/50296939
public class HanoiTower {
    public static void hanoi(int n, String a, String b,String c) {
        if (n == 1) {
            // 只有一个圆盘时直接从A石柱移动到C石柱
            move(n, a, c);
        } else {
            // 将前n-1个圆盘从石柱A移动到石柱B
            hanoi(n - 1, a, c, b);
            // 将第n号圆盘从石柱A移动到石柱C
            move(n, a, c);
            // 将前n-1个圆盘从石柱B移动到石柱C
            hanoi(n - 1, b, a, c);
        }
    }

    public static void move(int n, String i, String j) {
        System.out.println("第" + n + "个圆盘," + "从" + i + "移动到" + j);
    }

    public static void main(String[] args) {
        hanoi(3,"A","B","C");
    }
}

Java基础-面向对象(一)

上一篇:Python加密爆破器


下一篇:H5+ API 设置手机状态栏颜色以及沉浸式状态栏