JavaSE基础

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量175 收藏
点赞数
分类专栏： Java学习 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53737050/article/details/125469681
版权

Java流程控制

Scanner对象

  • 之前我们学习的基本语法中我们并没有实现程序和人的交互，但Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。

  • 基本语法

    Scanner s=new Scanner(System.in);

  • 通过Scanner类的**next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()**判断是否还有输入的数据。

  • next()

    Scanner s = new Scanner(System.in);
System.out.println("使用next方式接受：");

//判断用户有没有输入字符串
if (s.hasNext()) {
    //使用next方式接受
    String str = s.next();
    System.out.println("输入的内容为" + str);
}
//凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
s.close();

在这里插入图片描述

  1. 一定要读取到有效字符后才可以结束输入。
  2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  4. next()不能得到带有空格的字符串。
  • nextLine()
//从键盘接收数据
Scanner s=new Scanner(System.in);
System.out.println("使用nextLine方式接受：");
//判断是否还有输入
if(s.hasNextLine()){
    String str=s.nextLine();
    System.out.println("输入的内容为"+str);
}
s.close();

在这里插入图片描述

  1. 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
  2. 可以获得空白。

另一种方法：

//从键盘接收数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
String str = scanner.nextLine();
System.out.println("输入的内容为：" + str);
scanner.close();

在这里插入图片描述

  • hasNext()
Scanner s=new Scanner(System.in);

//从键盘接受数据
int i;
float f;

System.out.println("请输入整数： ");
//如果...那么
if(s.hasNextInt())
{
    i=s.nextInt();
    System.out.println("整数数据： "+i);

}
else{
    System.out.println("你输入的不是整数数据！ ");


}
System.out.println("请输入小数： ");
//如果...那么
if(s.hasNextFloat())
{
    f=s.nextFloat();
    System.out.println("小数数据： "+f);

}
else{
    System.out.println("你输入的不是小数数据！ ");


}

s.close();

在这里插入图片描述
在这里插入图片描述

//我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果。
Scanner s=new Scanner(System.in);

//和
double sum=0;
//计算输入了多少个数字
int m=0;
//通过循环判断是否还有输入，并在里面对每一次进行求和统计
while(s.hasNextDouble()){
    double x=s.nextDouble();
    m=m+1;//m++
    sum=sum+x;
    System.out.println("你输入了第"+m+"个数据，然后当前结果sum:"+sum);
}
System.out.println(m+ "个数的和为"+sum);
System.out.println(m+"个数的平均值是"+(sum/m));
s.close();

在这里插入图片描述

顺序结构

  • Java的基本结构就是顺序结构，除非特别指明，否则就是按照顺序一句一句执行。

  • 顺序结构是最简单的算法结构。

    在这里插入图片描述

  • 语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

System.out.println("hello1");
System.out.println("hello2");
System.out.println("hello3");
System.out.println("hello4");
System.out.println("hello5");

在这里插入图片描述

选择结构

if单选择结构

  • 我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示

  • 语法：

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

在这里插入图片描述

Scanner s=new Scanner(System.in);

System.out.println("请输入内容");
String a= s.nextLine();
//eqaus:判断字符串是否相等
if(s.equals("Hello")){
    System.out.println(a);

}
System.out.println("End");
s.close();

在这里插入图片描述
在这里插入图片描述

if双选择结构

  • 那现在有个需求，公司要收购一个软件，成功了，给人支付100万元，失败了，自己找人开发。这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构。
  • 语法：
if (布尔表达式){
    //如果布尔表达式的值为true
}else{
    //如果布尔表达式的值为false
}

在这里插入图片描述

//考试分数大于60分就是及格，小于60分就不及格。
Scanner scanner=new Scanner(System.in);
System.out.println("请输入成绩");
int score=scanner.nextInt();


if(score>60){
    System.out.println("及格");
}else{
    System.out.println("不及格");
}

scanner.close();

在这里插入图片描述

if多选择结构

  • 我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD,存在区间多级判断。比如90-100就是A，80-90就是B···等等，在生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题！
  • 语法：
if (布尔表达式1) {
    //如果布尔表达式1的值为true执行代码
} else if (布尔表达式2) {
    //如果布尔表达式2的值为true执行代码
} else if (布尔表达式3) {
    //如果布尔表达式3的值为true执行代码
} else {
    //如果以上布尔表达式的值都不为true执行代码
}

//考试分数大于60分就是及格，小于60分就不及格。
Scanner scanner = new Scanner(System.in);
/*
if语句至多有1个esle语句，else语句在所有的if else语句之后。
if语句可以有若干个else if语句，它们必须在else语句之前。
一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行。
 */

System.out.println("请输入成绩");
int score = scanner.nextInt();

if (score == 100) {
    System.out.println("恭喜满分");
} else if (score < 100 && score >= 90) {
    System.out.println("A级");
} else if (score < 90 && score >= 80) {
    System.out.println("B级");
} else if (score < 80 && score >= 70) {
    System.out.println("C级");
} else if (score < 70 && score >= 60) {
    System.out.println("D级");
} else if (score < 60 && score >= 0) {
    System.out.println("不及格");
} else {
    System.out.println("成绩不合法");
}
scanner.close();

在这里插入图片描述

嵌套的if结构

  • 使用嵌套的if···else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或else if语句。你可以像if语句一样嵌套else if···else。
  • 语法：
if (布尔表达式1) {
    //如果布尔表达式1的值为true执行代码
    if (布尔表达式2) {
        //如果布尔表达式2的值为true执行代码
    }
}

switch多选择结构

  • 多选择结构还有一个实现方式就是switch case语句。

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

    1.switch语句中的变量类型可以是：

    2.byte，short，int，或者char

    3.从Java SE 7开始

    4.switch支持字符串String类型了

    5.同时case标签必须为字符串常量或字面量

  • 语法：

switch (expression) {
    case value:
        //语句
        break;//可选
    case value:
        //语句
        break;//可选
    //你可以有任意数量的case语句
    default: //可选
        //语句
}

//case 穿透   //switch 匹配一个具体的值
char grade='A';
switch(grade){
    case 'A':
        System.out.println("优秀");
        break;//可选
    case'B':
        System.out.println("良好");
        break;//可选
    case'C':
        System.out.println("及格");
        break;//可选
    case'D':
        System.out.println("再接再厉");
        break;//可选
    case 'E':
        System.out.println("挂科");
        break;//可选
    default:
        System.out.println("未知等级");
}

在这里插入图片描述

String类型

String name = "秦疆";
//JDK7的新特性，表达式结果可以是字符串！！!
//字符的本质还是数字

//反编译  java---class(字节码文件)-----反编译（IDEA）
switch (name) {
    case "秦疆":
        System.out.println("秦疆");
        break;
    case "狂神":
        System.out.println("狂神");
        break;
    default:
        System.out.println("弄啥嘞！");
        
}

在这里插入图片描述

循环结构

while循环

  • while是最基本的循环，它的结构为：
while (布尔表达式){
    //循环内容
}

  • 只要布尔表达式为true，循环就会一值执行下去。

  • 我们大多数情况是会让循环停止下来的，我们需要一个让表达失败的方式来结束循环。

  • 少部分情况需要循环一直执行，比如服务器的请求响应监听等。

  • 循环结构一直为true就会造成无限循环[死循环]，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃！

输出1~100

//输出1~100
int i=0;

while(i<100){
    i++;
    System.out.println(i);

}

在这里插入图片描述

死循环：

//死循环
while(true){
    //等待客户端连接
    //定时检查
    //...
}

计算1+2+3+…+100=?

//计算1+2+3+···100=？
//高斯的故事
int i = 0;
int sum = 0;
while (i <= 100) {
    sum = sum + i;
    i++;
}
System.out.println(sum);

在这里插入图片描述

do…while循环

  • 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
  • do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
do {
    //代码语句
}while (布尔表达式);

int i = 0;
int sum = 0;
do {
    sum = sum + i;
    i++;
} while (i <= 100);
System.out.println(sum);

在这里插入图片描述

  • While和do…While的区别：

    ​ 1.while先判断后执行。dowhile是先执行后判断！

    ​ 2.Do…while总是保证循环体会被至少执行一次！这是他们的主要差别。

int a = 0;
while (a < 0) {
    System.out.println(a);
    a++;
}
System.out.println("========================");
do {
    System.out.println(a);
    a++;
} while (a < 0);

在这里插入图片描述

for循环

  • 虽然所有循环结构都可以用while或者do…while表示，但Java提供了另一种语句——for循环，使一些循环结构变得更加简单。
  • for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。
  • for循环执行的次数是在执行前就确定的。语法格式如下：
for (初始化;布尔表达式;更新){
    //代码语句
}

关于for循环有以下几点说明：
最先执行初始化步骤，可以声明一种类型，但可初始化一个或者多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值，如果为true，循环体被执行，如果为false,循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
再次检测布尔表达式，循环执行上面的过程。

死循环：

//死循环
for (; ; ) {

}

练习1：计算0到100之间的奇数和偶数的和。

//计算0到100之间的奇数和偶数的和。
int oddSum = 0;
int evenSum = 0;
for (int i = 0; i <= 100; i++) {
    if (i % 2 != 0) {//奇数
        oddSum += i;//oddSum=oddSum+i;
    } else {//偶数
        evenSum += i;
    }
}
System.out.println("奇数的和" + oddSum);
System.out.println("偶数的和" + evenSum);

在这里插入图片描述

练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

//用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
for (int i = 0; i <= 1000; i++) {
    if (i % 5 == 0) {
        System.out.print(i + "\t");
    }
    if (i % (5 * 3) == 0) {//每行
        System.out.println();
        //System.out.println("\n");

    }
}
//println 输出完会换行
//print  输出完不会换行

在这里插入图片描述

练习3：打印九九乘法表

//打印九九乘法表
//1.我们先打印第一列，这个大家应该都会
//2.我们把固定的1再用一个循环包起来
//3.去掉重复项：i<=j
//4.调整样式
for (int j = 1; j <= 9; j++) {
    for (int i = 1; i <= j; i++) {
        System.out.print(i + "*" + j + "=" + (j * i) + "\t");
    }
    System.out.println();
}

在这里插入图片描述

增强型for循环

  • 这里我们先只是见一面，做个了解，之后数组我们重点使用
  • Java5引入了一种主要用于数组或集合的增强型for循环。
  • Java增强for循环语法格式如下：
for (声明语句:表达式) {
    //代码语句
}
  • 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
  • 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
int[] numbers = {10, 20, 30, 40, 50};//定义了一个数组

for (int i = 0; i < 5; i++) {
    System.out.println(numbers[i]);
}

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

//遍历数组的元素
for (int x : numbers) {
    System.out.println(x);
}

在这里插入图片描述

break & continue

  • break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
int i = 0;
while (i < 100) {
    i++;
    System.out.println(i);
    if (i == 30) {
        break;
    }
}
System.out.println("123");

在这里插入图片描述

  • continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
int i = 0;
while (i < 100) {
    i++;
    if (i % 10 == 0) {
        System.out.println();
        continue;
    }
    System.out.print(i);
}
//break在任何循环语句的主体部分，均可用break控制循环的流程。
//break用于强制退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
//continue 语句用在循环语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

在这里插入图片描述

流程控制练习

打印三角形

//打印三角形 5行
for (int i = 1; i <= 5; i++) {
    for (int j = 5; j >= i; j--) {
        System.out.print(" ");
    }
    for (int j = 1; j <= i; j++) {
        System.out.print("*");
    }
    for (int j = 1; j < i; j++) {
        System.out.print("*");
    }
    System.out.println();

}

在这里插入图片描述

Java方法详解

何谓方法

  • System.out.println()，那么它是什么呢？

    System-----系统的类

    out-----------输出对象

    println-----------方法

    调用系统类里的标准输出对象out中的println方法

  • Java方法是语句的集合，它们在一起执行一个功能。

    ​ 1.方法是解决一类问题的步骤的有序组合

    ​ 2.方法包含于类或对象中

    ​ 3.方法在程序中被创建，在其他地方被引用

int sum = add(1, 2);
    System.out.println(sum);
}
//加法
public static int add(int a, int b) {

    return a + b;
}

在这里插入图片描述

  • 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只能完成一个功能，这样利于我们后期的扩展。

方法的定义以及调用

定义

  • Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

  • 方法包含一个方法和一个方法体，下面是一个方法的所有部分：

    1.修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

    2**.返回值类型**：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。

    3.方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

    4.参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型，顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

    ​ a.形式参数：在方法被调用时用于接受外界输入的数据。
    ​ b.实参：调用方法时实际传给方法的数据。

    5.方法体：方法体包含具体的语句，定义该方法的功能。

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
            ...
    return 返回值;
}

调用

  • 调用方法：对象名，方法名（实参列表）

  • Java支持两种调用方法的方式，根据方法是否返回值来选择。

  • 当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);
  • 如果方法返回值是void,方法调用一定是一条语句。
System.out.println("Hello,kuangshen!");

int max = max(10, 20);
    System.out.println(max);
}

//比大小
public static int max(int num1, int num2) {
    int result = 0;
    if (num1 == num2) {
        System.out.println("num1==num2");
        return 0;//终止方法
    }
    if (num1 > num2) {
        result = num1;
    } else {
        result = num2;
    }

    return result;
}

在这里插入图片描述

方法重载

  • 重载就是在一个类中，有相同的函数名称，但形参不同的函数。

  • 方法重载的规则：

    1.方法名称必须相同。

    2.参数列表必须不同（个数不同，或类型不同，参数排列顺序不同等）。

    3.方法的返回值类型可以相同也可以不相同。

    4.仅仅返回类型不同不足以成为方法的重载。

  • 实现理论：

    1.方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

可变参数

  • JDK 1.5开始，Java支持传递同类型的可变参数给一个方法。
  • 在方法声明中，在指定参数类型后加一个省略号（···）。
  • 一个方法中**只能指定一个可变参数，它必须是方法的最后一个参数。**任何普通的参数必须在它之前声明。
public static void printMax(double... numbers) {
    if (numbers.length == 0) {
        System.out.println("No argument passed");
        return;
    }
    double result = numbers[0];

    //排序
    for (int i = 1; i < numbers.length; i++) {
        if (numbers[i] > result) {
            result = numbers[i];
        }
    }
    System.out.println("The max value is " + result);
}

//调用可变参数的方法
    printMax(34, 3, 3, 2, 56.5);
    printMax(new double[]{1, 2, 3});

}

public static void printMax(double... numbers) {
    if (numbers.length == 0) {
        System.out.println("No argument passed");
        return;
    }
    double result = numbers[0];
    //排序！
    for (int i = 0; i < numbers.length; i++) {
        if (numbers[i] > result) {
            result = numbers[i];
        }
    }
    System.out.println("The max value is " + result);
}

在这里插入图片描述

递归

  • A方法调用B方法，我们很容易理解！

  • 递归就是：A方法调用A方法！就是自己调用自己

  • 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模比较小的问题来求解，递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

  • 递归结构包括两个部分：

    1.递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。

    2.递归体：什么时候需要调用自身方法。

//递归思想
public static void main(String[] args) {
    System.out.println(f(5));
}

public static int f(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n * f(n - 1);
    }

}

在这里插入图片描述

数组

数组的定义

  • 数组是相同类型数据的有序集合。
  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
  • 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组声明创建

  • 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变脸的语法：
dataType[] arrayRefVar; // 首选的方法
或
dataType[] arrayRefVar[]; //效果相同，但不是首选方法
  • Java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize];
  • 数组的元素是通过索引访问的，数组索引从0开始。
  • 获取数组长度：
arrays.length

int[] nums;//1.声明一个数组
nums = new int[10];//2.创建一个数组

//3.给数组元素中赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
//计算所有元素的和
int sum = 0;
for (int i = 0; i < nums.length; i++) {

    sum = sum + nums[i];
}
System.out.println("总和为" + sum);

在这里插入图片描述

数组使用

  • 普通的For循环
  • For-Each循环
  • 数组作方法入参
  • 数组作返回值
int[] arrays = {1, 2, 3, 4, 5};
//打印全部的数组元素
for (int i = 0; i < arrays.length; i++) {
    System.out.println(arrays[i]);
}

System.out.println("=========");
//计算所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
    sum += arrays[i];
}
System.out.println("sum=" + sum);
System.out.println("=========");
//查找最大元素
int max = arrays[0];

for (int i = 0; i < arrays.length; i++) {
    if (arrays[i] > max) {
        max = arrays[i];
    }
}
System.out.println("max=" + max);

在这里插入图片描述

多维数组

  • 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一位数组。

  • 二维数组

    int a[][]=new int[2][5];

//[4][2]
    /*
        1,2  array[0]
        2,3  array[1]
        3,4  array[2]
        4,5  array[3]
     */
    int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }

    }

}


//打印数组元素
public static void printArray(int[] arrays) {
    for (int i = 0; i < arrays.length; i++) {
        System.out.print(arrays[i] + " ");
    }

在这里插入图片描述

Arrays 类

  • 数组的工具类java.util.Arrays

  • 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个·工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。

  • 查看JDK帮助文档

  • Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）

  • 具有以下常用功能：

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

 int[] a = {1, 2, 3, 4, 9090, 312341, 32, 534, 21, 3, 23};
    System.out.println(a);//[I@723279cf
    //打印数组元素
    //System.out.println(Arrays.toString(a));
    //printArray(a);
    Arrays.sort(a);//数组进行排序，升序
    System.out.println(Arrays.toString(a));

    Arrays.fill(a, 2, 4, 0);//数组填充
    System.out.println(Arrays.toString(a));

}

public static void printArray(int[] a) {
    for (int i = 0; i < a.length; i++) {
        if (i == 0) {
            System.out.print("[");
        }
        if (i == a.length - 1) {
            System.out.print(a[i] + "]");
        } else {
            System.out.print(a[i] + ", ");


        }
    }

在这里插入图片描述

面向对象编程（OOP）

面向过程&面向对象

  • 面向过程思想

    1.步骤清晰简单，第一步做什么，第二步做什么.·····

    2.面对过程适合处理一些较为简单的问题

  • 面向对象思想

    1.物以类聚，分类的思想模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。

    2.面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

  • 面向对象编程（Object-Oriented Programming,OOP）

  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

  • 抽象：编程思想！持续的学习，茅塞顿开！多实践，多测试大脑中的想法！实践出真知~

  • 三大特性：

    封装
    继承
    多态

  • 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

  • 从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法回顾和加深

  • 方法的定义

    1.修饰符

    2.返回类型

    3.break：跳出switch，结束循环和return的区别

    4.方法名：注意规范就OK 见名知意

    5.参数列表：（参数类型，参数名）···

    6.异常输出：疑问，后面讲解

  • 方法的调用： 递归

    a.静态方法

    b.非静态方法

    c.形参和实参

    d.值传递和引用传递

    e.this关键字

/*
修饰符 返回值类型  方法名（...）{
//方法体
return 返回值;
}
 */
//return 结束方法， 返回一个结果！
public String sayHello() {

    return "hello,world";

}

public void print() {

    return;

}

public int max(int a, int b) {
    return a > b ? a : b;//三元运算符！
}

//数组下标越界： Arrayindexoutofbounds
public void readFile(String file) throws IOException {


}

Person person = new Person();
        System.out.println(person.name);//null
        d04.change(person);
        System.out.println(person.name);//秦疆
}
    public static void change(Person person){
        //person是一个对象：指向的--->erson person = new Person();这是一个具体的人，可以改变属性！
        person.name="秦疆";
    }
}
//定义了一个Person类，有一个属性；name
class Person{
    String name;//null
}

在这里插入图片描述

类与对象的关系

  • 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。

    1.动物、植物、手机、电脑·····

    2.Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

  • 对象是抽象概念的具体实例

    1.张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。

    2.能够体现出特点、展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

  • 使用new关键字创建对象

  • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

    1.必须和类的名字相同
    2.必须没有返回类型，也不能写void

  • 构造器必须要掌握

爱学习的小文
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
javaSE基础
03-26
1-5讲，关于数据类型，函数和数组 1. jvm：java虚拟机，执行class文件 2. jre：java运行环境，包含：jvm和核心类库 3. jdk：java开发工具包，包含：jre和开发工具
JavaSE基础（一）
07-19
JavaSE基础是学习Java编程语言的核心部分，涵盖了Java开发所需的各项基础知识。让我们深入探讨这些关键概念。 1. **JDK**：全称为Java Development Kit，是Java编程的基础，提供了开发和运行Java应用程序所需的所有...
JavaSE基础.md
06-29
javaSE基础，查漏补缺必备
javase基础
05-01
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 315
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 435
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 235
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 605
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 253
集合之Map
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 729
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 416
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 465
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java8新特性之FlatMap&Reduce
startqbb的博客
07-26 197
【代码】Java8新特性之FlatMap&Reduce。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 158
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 217
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 652
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 886
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
Java —— 线程
JL_L666的博客
07-26 677
程序(program)：为完成特定的任务，选用某一种语言编写的，即指，静态对象。进程(process)：程序的一次执行过程，或是。程序是静态的、进程是。进程是调度和分配资源的最小单位。注意：不同的进程之间是不共享内存的、进程之间的数据交换和通信的成本很高。线程(thread)：进程可以进一步细化为线程，是运行中进程的一条或多条执行路径。线程调度策略单核CPU与多核CPU并行与并发上。
Java基础
m0_74074214的博客
07-26 665
方法需要定义在类体中，方法是类体中的一员，每个方法之间都是并列的。语法如下：[访问权限修饰符] [其他修饰符] [返回值类型] 方法名（[参数列表]）{code //方法体return；注意：中括号[ ]表示可有可无的部分，需要的话就写上，如果不需要就不写，方法名是一种标识符，需要使用小驼峰命名法方法与方法间是并列平级的，不允许出现方法嵌套方法//定义一个方法： 返回两个int类型的变量的最大值if(a>=b){return a;}else{
javaSE基础项目实战
06-01
JavaSE基础项目实战是为Java初学者提供的一个实践项目，它可以帮助初学者通过实战的方式掌握JavaSE的基础知识和编程技巧。该项目包含以下内容： 1. 基础语法练习：包括JavaSE中的基本数据类型、流程控制语句、数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱学习的小文

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值