Java基础学习

Posted 2020-10-29 阿来丶

软件设计原则:

为了提高软件的开发效率，降低软件开发成本，一个优良的软件系统应该具有以下特点：

1,可重用性：遵循DRY原则，减少软件中的重复代码。

2,可拓展性：当软件需要升级增加新的功能，能够在现有的系统架构上方便地创建新的模块，而不需要改变软件现有的结构，也不会影响以及存在的模块。

3,可维护性：当用户需求发生变化时，只需要修改局部的模块中的少量代码即可。

如何让软件系统达到上述的特点，我们对模块的其他要求： 低耦合高内聚！！

1：高内聚性：内聚，强调一个模块内的功能联系，每个模块只完成特定的功能，不同模块之间不会有功能的重叠，高内聚性可以提高软件的可重用性和可维护性。

2：低耦合性：耦合，强调的是多个模块之间的关系，模块之间相互独立，修改某一个模块，不会影响到其他的模块。低耦合性提高了软件的可维护性。

 

---

装箱：把基本数据类型，转换成包装类型。

拆箱：把包装类型，转换成基本数据类型。

 

装箱：

Intger i = new Intger(1);

Intger i = Intger.valueof(1);

Intger i = 1;//自动装箱

 

拆箱：

Intger un = 10;

int i = in.intValue();//拆箱

int i = in; //自动拆箱 或 int i = new Intger(1);

 

字符串->int

int i = Integer.parseInt();

 

int->字符串

String s = String.valudOf();

String s = Ingeter.toString();

String s = 123+"";

---

Arrays工具类： 是Java中提供的用于操作数组的工具类，位于java.util包中。

 

1. copyOf：复制出新的数组，复制长度由 newLength 决定,长度可大于被复制数组的长度。>原长度，用默认值补齐；<原长度，只复制前半部分。

Integer[] arr = {1,2,3,4,5,6,7};

Integer[] brr = Arrays.copyOf(arr, 8);

2. sort：默认进行升序排序，可自定义排序。（自定义排序是自定义从哪个下标到哪个下标之间进行排序，左闭右开）
3. toString：数组输出语句，不用使用循环，可直接输出数组所有值。
4. equals：比较数组内容是否相等。（==则比较的是数组的地址）
5. fill：将一个数组全部置为同一个值 ，或在下标范围内将数组置为同一个值。
6. binarySearch：二分查找法找指定元素的下标，找不到则返回负数。（必须是排序好的数组）
7. copeOf和copeOfRange： 截取数组。（copeOf（截取到第几位），copeOfRange（截取第几个到第几个））。

 

二维数组：

写法：数据类型[][] 数组名 

例子：int[][] arr = {{2,5},{1},{3,2,4},{1,7,5,9}};

for (int i = 0; i < arr.length; i++) {

for (int j = 0; j < arr[i].length; j++) {

System.out.println(arr[i][j]);

}

}

---

 

---

 

一、String类

String类在java.lang包中，不需要导包，自动导入，字符串变量属于对象。java把String类声明的final类，不能被继承。

String类对象创建后不能修改，由0个或多个字符组成，包含在一对双引号之间。

写法：

自变量声明：String s = " 数据 ";

使用new关键字声明： String s = new String("数据");

二、String类常用方法

1、求字符串的长度 (String.length())

String s = new String(abcdefg"); int slength = str.length();

2、字符串比较 （String.equals()）

s.equals()的比对原理是判断两个字符串的每一个字符是否相等。

== 比较的是两个字符串中存储的地址是否想等。

s.equalsIgnoreCase(s)：忽略大小写进行比对。

3、字符串中字符的大小写转换

s.toLowerCase()：返回当前字符串中所有字符转换成小写

s.toUpperCase()：返回当前字符串中所有字符转换成大写

4、连接字符串

①使用+连接

②使用concat连接，需要返回一个新的字符串。

String s = "a".concat("b").concat("c"); 相当于String s = "a"+"b"+"c";

5、字符串的查找

s.indexOf():用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置。从0开始，若没有出现则返回-1。

可以接受字符串，字符，整数类型的参数，如果参入整数，将根据ASCII码自动转换字符（A=65,a=97）。

s.lastIndexOf():与indexOf()类似，但是查找的是字符串最后出现的位置。从0开始，若没有出现则返回-1。

6、截取字符串

s.substring(int a):从a所在的字符串的位置开始进行截取，截取到字符串到最后，并返回一个新的字符串。

s.substring(int a,int b):表示从a截取到b，为左闭右开区间，包含起点不包含终点。

7、去空格

s.trim()：截去字符串两端的空格，但对于中间的空格不处理。

8、替换

s.replace(oldChar, newChar):将字符串中的所有oldChar替换成newChar。

9、字符串分割 （返回的是字符串数组类型）

s.split(regex)：传入指定字符，将字符串分割为多个子串，返回一个字符串类型的数组，如果传入一个空字符串，则对原字符串全部分割。

s.split(regex, limit)：表示将当前字符串分割成几部分，如果传入的数字少于分割的总部分，那么分割limit后多余的字符串将不会分割。

三、StringBuffer

1.StringBuffer是String的增强版，位于java.long包中，不需要导包可直接使用，它与String最大的区别在于：StringBuffer在声明后是可以改变可以追加的。而String一旦声明，不可改变，不可追加。

写法：

StringBuffer sb = new StringBuffer("abc");

　　需要注意的是，StringBuffer和String属于不同的类型，也不能直接进行强制类型转换

　　String转换为StringBuffer： StringBuffer sb2 = new StringBuffer(s);

　　StringBuffer转换为String： String s1 = sb1.toString();

2.常用的方法：

(a)、sb.toString():将StringBuffer转换成String进行输出，在输出时可以不用转换，系统会自动转换。

(b)、sb.append() :在原字符串之后追加新的字符，原字符串会直接改变，同时还会追加之后的字符串返回。append()可以接受各种类型的参数，会自动转成字符串追加到原字符串最后。

(c)、sb.delete(int start,int end):传入两个下标，表示删除这两个下标之间的字符。（左闭右开区间）

(d)、sb.deleteCharAt(index) : 传入一个下标，表示删除指定位置的一个字符。

(e)、sb.insert(index,b):该方法的作用是在StringBuffer对象中的指定位置插入内容，然后形成新的字符串。新的子串可以是任何数据类型，其他数据类型会自动转换成字符串。

(f)、sb.reverse()： 字符串反转，将sb的字符串翻转后形成新的字符串。

 

---

　　一、面向对象 & 面向过程

　　　　面向过程：专注于如何去解决一个问题的过程。特点：每一个功能都出现了函数，也就是由一个个函数实现解决问题的一系列步骤。（C语言）

　　　　面向对象：专注于由哪个对象来解决问题,而调用者无需关注对象实现的细节。特点：出现了一个个类，从类中拿到对象，通过对象解决问题。（java、php、c++、c#、Python）

　　　 　面向机器： 汇编语言。

面向对象的三大特征： 继承，封装，多态。

二：类 & 对象

类:具有相同属性和行为的个体的集合就是类。类是一个抽象的概念，只能说类具有那些属性，而不能对属性赋值，因此对象的抽象化是类，类的具体化就是对象。

　　　　类具有属性，对象的属性，用成员变量来描述,通过封装数据实现。

　　　　类具有行为，对象的行为，用方法来描述。

对象：从类中拿出具有属性值的个体，称为对象。 对象是从类中拿出的一个具体的个体，需要对属性进行具体的赋值。

类和对象的关系: 对象的抽象化是类，类的具体化就是对象。

　　 　　类是对象的描述，对象是类的个体。

　　　　程序中由类产生对象。

 

声明一个类：[修饰符]  class   类名{

[修饰符] 属性类型 属性名

[修饰符] 返回值类型 方法名

}

 

步骤：

　　　　(1):声明一个类，并且声明类中的属性和方法。

　　　　(2):实例化一个类，在主函数中使用new关键字实例化。

　　　　(3):使用类中的属性、方法。

 

定义类的注意:

   　　 (1):如果类使用了public修饰符,必须保证当前文件名称和当前类名相同.

   　　 (2):类名使用名称表示,类表示某一类事物,首字母大写,如果是多个单词组成使用驼峰表示法.

    　　(3):在面向对象的过程中,各位定义类的时候,专门为描述对象提供一个类,该类不需要main方法.

构造函数：

　　　　 (1):构造函数与类名相同。

　　　　(2):构造函数没有返回值（void都没有），不需要使用return语句。

　　　　(3):构造函数分为有参构造函数和无参构造函数。

 

构造函数的作用：在实例化对象的时候，赋初始值。

 

 

　　构造函数无需手动调用，在实例化对象的时候会自动调用。

注意：如果没有写构造函数，那么系统会自动创建一个缺省的构造函数；如果写了带参构造函数，那么会覆盖掉缺省的构造函数。

 

三、方法

方法定义格式:

    [修饰符]  返回值的类型  方法名称([形式参数,....])

    {

             方法体

             [return 值];

    }

方法的返回值：

(1):如果方法没有返回值，不能使用return，并且方法的返回值类型使用的void。

(2):如果方法有返回值，使用return返回相应的返回值类型。

(3):有返回值的方法不一定需要接收返回值。

(4):没有返回值的方法一定不能接受返回值。

什么时候使用返回值？ 如果需要返回一个结果数据,我们就把该结果数据的类型作为该方法的返回值类型.

方法的调用：

(1):声明的方法，只有在调用的时候才能执行方法体中的代码。

(2):在本类中调用其他方法直接使用方法名();或者使用this.方法名();

(3):调用其他类中的方法，需要先实例化对象，然后通过对象名调用方法。即：对象名.方法()；

方法的参数：

声明方法时可以在方法圆括号中的进行定义,仅仅只是占位而已,参数的名称其实无所谓,形式参数可以有多个，用逗号分隔。

声明方法时的参数列表，称为形参列表。

调用方法时，必须按照形参列表的顺序进行赋值，此时的参数称为实参列表。

什么时候使用参数？ 该方法在完成该功能的过程之中,是否有未知的因素参与,如果有请作为参数传递,如果没有则没有形参.

 

四、成员变量 & 局部变量：

成员变量：直接在类中声明的属性称为成员变量。成员变量的作用范围在整个类中可以使用。

局部变量：在方法体里面声明的变量称为局部变量。局部变量只在当前方法体中有效，方法的形参都输入局部变量。

区别： (1):作用域不同。成员变量作用于整个类中，局部变量作用于方法中。

(2):初始值不同。成员变量会默认赋初始值，局部变量没有默认初始值。

(3):优先级不同。当成员变量与局部变量重名时，方法中优先使用局部变量，如果需要使用成员变量需要使用this关键字。