JAVA学习历程

最新推荐文章于 2024-06-26 21:36:08 发布

taraex

最新推荐文章于 2024-06-26 21:36:08 发布

阅读量7.4k

点赞数 5

分类专栏： JAVA

本文链接：https://blog.csdn.net/taraex/article/details/89187761

版权

JAVA 专栏收录该内容

23 篇文章 4 订阅

订阅专栏

JAVA

数组

概念：
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

数组定义格式
格式1：数据类型[] 数组名；
格式2：数据类型数组名[];

数组的初始化：JAVA中的数组必须初始化才能使用。
动态初始化: 只指定长度，由系统给出初始化值。
数据类型[] 数组名 = new 数据类型[数组长度]
int[] arr = new int3; 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值

Java中的内存分配以及栈和堆的区别
栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
堆: 存放的是所有new出来的东西
特点：
a: 每一个new出来的东西都会为其分配一个地制值。
b: 每一个变量都有一个默认的值
byte，short，int，long – 0
float，double – 0.0
char – ‘\u0000’
boolean – false
引用数据类型 – null
c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
方法区:(面向对象部分讲解)
本地方法区:(和系统相关)
寄存器:(cpu使用)
动态初始化数组的内存图：
在这里插入图片描述
数组的操作：反转
例：int[] arr = {11,22,33,44,55};
打印的结果为: [55,44,33,22,11]

public class zuoye5 {
    public static void main(String[] args) {
        int []arr = {11,22,33,44,55};
        for (int i = arr.length-1; i>=0; i--) {
            System.out.println(arr[i]);
        }
    }

二维数组

概念：
二维数组其实就是每一个元素为一维数组的数组

二维数组的定义格式：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组必须写上
n表示每一个一维数组的元素个数可选

	int[][] arr = new int[3][2];
	定义了一个二维数组arr
	这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
	每个一维数组有2个元素

二维数组内存图：
在这里插入图片描述
二维数组的遍历：
可以使用for循环，两层嵌套；外层循环控制二维数组的长度，即一维数组的个数，内层循环控制一维数组的长度
二维数组的求和：
案例：打印杨辉三角如下：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
代码：

public class erweiDemo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数");
        int a = sc.nextInt();
        int [][]arry = new int[a][a];
        for (int i = 0; i < arry.length; i++) {
            for (int j = 0; j < arry[i].length; j++) {

                arry[i][0] = 1;
                arry[i][i] = 1;

            }
        }
        for (int i = 2; i < arry.length; i++) {
            for (int j = 1; j < arry[i].length; j++) {
                arry[i][j] = arry[i - 1][j - 1] + arry[i - 1][j];


            }
        }
                    for (int i = 0; i < arry.length; i++) {
                        for (int j = 0; j <= i; j++) {

                            System.out.print(arry[i][j]+"\t");

                        }
                        System.out.println();

                }

    }
}

递归

递归的思想：
拆分合并

注意事项：
要有出口，否则就是死递归
次数不能太多，否则就内存溢出

求一个数的阶乘：
在这里插入图片描述

public class DiguiDemo1{
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个数");
            int a = sc.nextInt();
            int r=jiecheng(a);
            System.out.println("这个数的阶乘是："+"\n"+r);
        }

        private static int jiecheng(int one ) {
            if (one==1){
                return 1;
            }else {
                return one*jiecheng(one-1);
            }

        }
    }

面向对象的思想

概述：
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，
能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想

简单的说，就是当我们想要去完成一件事的时候，我们去找一个人，让他来做这件事，而我们只用指挥他去干这件事就行了

面向对象思想的特征：
封装(encapsulation)
继承(inheritance)
多态(polymorphism)

类和对象的概述

我们如何描述现实世界事物
举例: 描述学生事物
姓名 , 年龄 , 性别 …
学习 , 吃饭 , 睡觉 …
属性: 就是该事物的描述信息
行为: 就是该事物能够做什么
我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
由此我们就得到了现实中的事物和类的对应关系
事物 ---------------- 类
属性 ----------------- 成员变量
行为 ----------------- 成员方法

定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法和以前定义方法是一样的，只不过把static去掉

概念：
a:类：是一组相关的属性和行为的集合
b:对象：是该类事物的具体体现
c:举例：
类学生
对象班长就是一个对象

定义一个电脑类，并且使用
包括属性，行为

public class Computer {
    String name ;
    String Servicelife ;
    public void playgame(){
        System.out.println("启动英雄联盟");
    }
    public void onlineShopping(){
        System.out.println("打开淘宝网页，进行选购");
    }

}

public class Mytest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.name="戴尔";
        computer.Servicelife="3年";
        System.out.println(computer.name);
        System.out.println(computer.Servicelife);
        computer.playgame();
        computer.onlineShopping();
    }
}

面向对象的内存图（三个引用两个对象）
在这里插入图片描述

成员变量和局部变量的区别

A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上（形参）
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

匿名对象

就是没有名字的对象
匿名对象应用场景
a:调用方法，仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递

封装

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。

private关键字的引入：
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问
最常见的应用：
将成员变量隐藏，然后提供对应的getxxx()和setxxx()方法

案例演示：利用封装来定义一个类

public class Person {
 
    private int age;

    public void setAge(int nianling){
        if(nianling>=0&&nianling<=100){
            age = nianling;
        }else{
            System.out.println("设置的年龄不合理");
        }

    }
    public int getAge(){
        return age;
    }
    public void show() {
       
        System.out.println(age);
    }
}

this关键字

当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题

特点：
是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁

public class Phone {
    private String name;
    private double price;

   
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public void call() {
        System.out.println("打电话");
    }
}

构造方法

构造方法概述和作用：
创建对象,给对象中的成员进行初始化

格式特点：
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值
注意事项：
a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

给成员变量赋值的两种方式
a:setXxx()方法
b:构造方法

定义标准手机类并进行测试

2、	public class MobilePhone {
     private String name ;
     private int price;
     private String serviceLife;
    public MobilePhone(){

    }
    public MobilePhone(String name,int price,String serviceLife){
         this.name = name;
         this.price = price;
         this.serviceLife = serviceLife;


    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getServiceLife() {
        return serviceLife;
    }

    public void setServiceLife(String serviceLife) {
        this.serviceLife = serviceLife;
    }
}

public class Mytest2 {
    public static void main(String[] args) {
        MobilePhone mobilePhone = new MobilePhone();
        mobilePhone.setName("苹果");
        mobilePhone.setPrice(5000);
        mobilePhone.setServiceLife("三年");
        mobilePhone.getName();
        mobilePhone.getPrice();
        mobilePhone.getServiceLife();
        System.out.println(mobilePhone.getName());
        System.out.println(mobilePhone.getPrice());
        System.out.println(mobilePhone.getServiceLife());
        System.out.println("-----------------------");
        MobilePhone mobilePhone1 = new MobilePhone("苹果",5000,"三年");
        mobilePhone1.getName();
        mobilePhone1.getPrice();
        mobilePhone1.getServiceLife();
        System.out.println(mobilePhone1.getName());
        System.out.println(mobilePhone1.getPrice());
        System.out.println(mobilePhone1.getServiceLife());


    }

static关键字的引入

特点：
a:随着类的加载而加载
b:优先于对象存在
c:被类的所有对象共享
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的
d:可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。

注意事项：
a:在静态方法中是没有this关键字的
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在
b:静态方法只能访问静态的成员变量和静态的成员方法

static关键字的内存图：
在这里插入图片描述

静态变量和成员变量的区别

A:所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用

如何使用JDK提供的帮助文档

A:找到文档，打开文档
B:点击显示，找到索引，出现输入框
C:你应该知道你找谁?举例：Scanner
D:看这个类的结构(需不需要导包)
java.lang包下的内容不需要我们手动导入
其它包下的内容需要我们手动导入
类 API文档
成员变量字段摘要
构造方法构造方法摘要
成员方法方法摘要
E:看这个类的说明(简单的了解一下)
F:看开始版本
G:看构造方法
H:看成员方法
看左边:
是否是static的,如果是我们就不需要创建对象,直接可以使用类名调用该方法;看返回值,返回值是什么我就使用什么接收
看右边:
看参数列表: 参数的个数 , 参数的类型 ; 要什么参数我是用的时候,就传递什么参数
I:然后使用

Math类的随机数功能

打开JDK提供的帮助文档学习
A:Math类概述
类包含用于执行基本数学运算的方法
B:Math类特点
由于Math类在java.lang包下，所以不需要导包。
没有构造方法，因为它的成员全部是静态的。
C:获取随机数的方法
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
D:我要获取一个1-100之间的随机数，肿么办?
int number = (int)(Math.random()*100)+1;

案例：
随机数小游戏：此游戏是一个猜数的游戏，电脑随机出1—100的一个整数，用户在控制台输入一个数，如果输入的数和随机出来的数相同，则代表答对了，否则代表答错，继续猜，但是只能有10次
会，十次用完，程序结束，而且每次失败都会提醒剩下的次数
代码：

import java.util.Scanner;

public class Guessnumber {
    public static void main(String[] args) {
        int num = (int)(Math.random()*100+1);
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个1---100的整数");
        int count=10;
         while (true){
            int usernum = scanner.nextInt();
            if(usernum>num){
                System.out.println("输入的数大了");
                count--;
            }else if (usernum<num){
                System.out.println("输入的数小了");
                count--;
            }else {
                System.out.println("恭喜你！猜对了");
                break;
            }
         if(count>=1){
             System.out.println("还有"+count+"机会");

         }else {
             break ;
         }


        }
      }
 }

总结

主要学习了面向对象的思想，构造方法，以及一些关键字。随着学习的东西增多，已经入门JAVA，相较于之前学习的东西，难度有所加大，需要大量练习才能掌握。但是随着学习的深入，对JAVA这门语言的兴趣相较以前有很大提升，我会努力保持多练习敲代码，同时会借助书本去挖掘更深层次的东西。

欢迎使用Markdown编辑器

你好！这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

全新的界面设计 ，将会带来全新的写作体验；
在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
全新的 KaTeX数学公式 语法；
增加了支持甘特图的mermaid语法¹ 功能；
增加了 多屏幕编辑 Markdown文章功能；
增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
增加了 检查列表 功能。

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G

合理的创建标题，有助于目录的生成

直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

~~删除文本~~

引用文本

H₂O is是液体。

2¹⁰ 运算结果是 1024.

插入链接与图片

链接: link.

图片:

带尺寸的图片:

居中的图片:

居中并且带尺寸的图片:

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

生成一个适合你的列表

项目
- 项目
  - 项目

项目1
项目2
项目3

计划任务
完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

TYPE	ASCII	HTML
Single backticks	`'Isn't this fun?'`	‘Isn’t this fun?’
Quotes	`"Isn't this fun?"`	“Isn’t this fun?”
Dashes	`-- is en-dash, --- is em-dash`	– is en-dash, — is em-dash

创建一个自定义列表

Markdown

Text-to- HTML conversion tool

Authors

John

Luke

如何创建一个注脚

一个具有注脚的文本。²

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 $\Gamma(n) = (n-1)!\quad\forall n\in\mathbb N$ 是通过欧拉积分

$\Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,.$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

关于 甘特图 语法，参考这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：:

这将产生一个流程图。:

关于 Mermaid 语法，参考这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

关于 Flowchart流程图 语法，参考这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件或者.html文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

mermaid语法说明 ↩︎
注脚的解释 ↩︎

taraex

关注

5
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
JAVA学习历程

JAVA数组概念：数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型。数组定义格式格式1：数据类型[] 数组名；格式2：数据类型数组名[];数组的初始化：JAVA中的数组必须初始化才能使用。动态初始化: 只指定长度，由系统给出初始化值。数据类型[] 数组名 = new 数据类型[数组长度]int[] ar...
复制链接

扫一扫