javase学习——面向对象（上）
1. 面向对象编程
1.1 什么是类
类是一类具有相同特性的事物的抽象描述，是一组相关属性和行为的集合。
- 属性：就是该事物的状态信息。
- 行为：就是在你这个程序中，该状态信息要做什么操作，或者基于事物的状态能做什么。
1.2 什么是对象
即对象是类的一个实例，必然具备该类事物的属性和行为
1.3 如何定义类
【修饰符】 class 类名{
}
如：
public class Student{
}
1.4 对象的创建
new 类名()//也称为匿名对象
//给创建的对象命名
//或者说，把创建的对象用一个引用数据类型的变量保存起来，这样就可以反复使用这个对象了
类名 对象名 = new 类名();
2. 成员变量
2.1 声明成员变量
【修饰符】 class 类名{
【修饰符】 数据类型 成员变量名;
}
public class Person{
String name;
char gender;
int age;
}
位置要求：必须在类中，方法外
类型要求：可以是Java的任意类型，包括基本数据类型、引用数据类型（类、接口、数组等）
修饰符：成员变量的修饰符有很多，例如：public、protected、private、static、volatile、transient、final等
2.2 对象的实例变量
实例变量的默认值
| 分类 | 数据类型 | 默认值 |
|---|---|---|
| 基本类型 | 整数（byte，short，int，long） | 0 |
| 浮点数（float，double） | 0.0 | |
| 字符（char） | ‘\u0000’ | |
| 布尔（boolean） | false | |
| 数据类型 | 默认值 | |
| 引用类型 | 数组，类，接口 | null |
3. 方法
3.1 方法的概念
方法也叫函数，是一组代码语句的封装，从而实现代码重用，从而减少冗余代码。
通常它是一个独立功能的定义，方法是一个类中最基本的功能单元。
3.2 方法的特点
1. 先声明后使用
2. 不调用不执行，调用一次执行一次
3.3 方法的声明
1. 声明的位置
类{
方法1(){
}
方法2(){
}
}
2. 声明方法的语法格式
【修饰符】 返回值类型 方法名(【形参列表 】)【throws 异常列表】{
方法体的功能代码
}
4. 参数问题
4.1 可变参数
当定义一个方法时，形参的类型可以确定，但是形参的个数不确定，那么可以考虑使用可变参数。可变参数的格式：
【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型... 形参名){ }
可变参数的特点和要求：
（1）一个方法最多只能有一个可变参数
（2）如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个
（3）在声明它的方法中，可变参数当成数组使用
（4）其实这个书写 “≈” 【修饰符】 返回值类型 方法名(【非可变参数部分的形参列表,】参数类型[] 形参名){ }
- 方法只有可变参数
package com.atguigu.test05.param;
public class NumberTools {
int total(int[] nums){
int he = 0;
for (int i = 0; i < nums.length; i++) {
he += nums[i];
}
return he;
}
int sum(int... nums){
int he = 0;
for (int i = 0; i < nums.length; i++) {
he += nums[i];
}
return he;
}
}
- 方法既有可变参数又有不可变参数
package com.atguigu.test05.param;
public class StringTools {
String concat(char seperator, String... args){
String str = "";
for (int i = 0; i < args.length; i++) {
if(i==0){
str += args[i];
}else{
str += seperator + args[i];
}
}
return str;
}
}
4.2 参数的传递机制
1. 方法的形参是基本数据类型时，形参值的改变不会影响实参；
2. 方法的形参是引用数据类型时，形参地址值的改变不会影响实参，但是形参地址值里面的数据的改变会影响实参，例如，修改数组元素的值，或修改对象的属性值。
5. 重载（overload）
- 方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
- 参数列表：数据类型个数不同，数据类型不同（按理来说数据类型顺序不同也可以，但是很少见，也不推荐，逻辑上容易有歧义）。
- 重载方法调用：JVM通过方法的参数列表，调用匹配的方法。
- 先找个数、类型最匹配的
- 再找个数和类型可以兼容的，如果同时多个方法可以兼容将会报错
6. 递归
方法自己调用自己的现象就称为递归。
// 计算斐波那契数列（Fibonacci）的第n个值，斐波那契数列满足如下规律，1,1,2,3,5,8,13,21,....
package com.atguigu.test07.recursion;
public class FibonacciTest {
public static void main(String[] args) {
FibonacciTest t = new FibonacciTest();
//创建FibonacciTest的对象，目的是为了调用f方法
for(int i=1; i<=10; i++){
System.out.println("斐波那契数列第" +i +"个数:" + t.f(i));
}
System.out.println(t.f(20));//6765
}
//使用递归的写法
int f(int n){//计算斐波那契数列第n个值是多少
if(n<1){//负数是返回特殊值1，表示不计算负数情况
return 1;
}
if(n==1 || n==2){
return 1;
}
return f(n-2) + f(n-1);
}
}
7. 对象数组
1. 数组是用来存储一组数据的容器，一组基本数据类型的数据可以用数组装，那么一组对象也可以使用数组来装。
2. 即数组的元素可以是基本数据类型，也可以是引用数据类型。当元素是引用数据类型是，我们称为对象数组。
7.1 二维数组
二维数组：本质上就是元素为一维数组的一个数组。
int[][] arr; //arr是一个二维数组，可以看成元素是int[]一维数组类型的一维数组
1. 二维数组也可以看成一个二维表，行*列组成的二维表==，只不过这个二维表，每一行的列数还可能不同。但是每一个单元格中的元素的数据类型是一致的，例如：都是int，都是String等。
2. 二维数组也可以看成一个一维数组，只是此时元素是一维数组对象
7.2 二维数组的声明
元素的数据类型[][] 二维数组的名称;
public class Test20TwoDimensionalArrayDefine {
public static void main(String[] args) {
//存储多组成绩
int[][] grades;
//存储多组姓名
String[][] names;
}
}
7.3 二维数组的静态初始化
//以下格式要求声明与静态初始化必须一起完成
元素的数据类型[][] 二维数组的名称 = {
{元素1，元素2，元素3 。。。},
{第二行的值列表},
...
{第n行的值列表}
};
元素的数据类型[][] 二维数组名 = new 元素的数据类型[][]{
{元素1，元素2，元素3 。。。},
{第二行的值列表},
...
{第n行的值列表}
};
元素的数据类型[][] 二维数组名;
二维数组名 = new 元素的数据类型[][]{
{元素1，元素2，元素3 。。。},
{第二行的值列表},
...
{第n行的值列表}
};
int[][] arr = {{1,2,3},{4,5,6},{7,8,9,10}};//声明与初始化必须在一句完成
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};
int[][] arr;
arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};
arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9,10}};//错误，静态初始化右边new 数据类型[][]中不能写数字
7.4 二维数组的使用
1. 二维数组的长度/行数：二维数组名.length
2. 二维数组的某一行：二维数组名[行下标]，此时相当于获取其中一组数据。它本质上是一个一维数组。行下标的范围：[0, 二维数组名.length-1]。此时把二维数组看成一维数组的话，元素是行对象
3. 某一行的列数：二维数组名[行下标].length，因为二维数组的每一行是一个一维数组。
4. 某一个元素：二维数组名\[行下标\]\[列下标\]，即先确定行/组，再确定列。
public class Test22TwoDimensionalArrayUse {
public static void main(String[] args){
//存储3个小组的学员的成绩，分开存储，使用二维数组。
/*
int[][] scores1;
int scores2[][];
int[] scores3[];*/
int[][] scores = {
{85,96,85,75},
{99,96,74,72,75},
{52,42,56,75}
};
System.out.println(scores);//[[I@15db9742
System.out.println("一共有" + scores.length +"组成绩.");
//[[：代表二维数组，I代表元素类型是int
System.out.println(scores[0]);//[I@6d06d69c
//[：代表一维数组，I代表元素类型是int
System.out.println(scores[1]);//[I@7852e922
System.out.println(scores[2]);//[I@4e25154f
//System.out.println(scores[3]);//ArrayIndexOutOfBoundsException: 3
System.out.println("第1组有" + scores[0].length +"个学员.");
System.out.println("第2组有" + scores[1].length +"个学员.");
System.out.println("第3组有" + scores[2].length +"个学员.");
System.out.println("第1组的每一个学员成绩如下：");
//第一行的元素
System.out.println(scores[0][0]);//85
System.out.println(scores[0][1]);//96
System.out.println(scores[0][2]);//85
System.out.println(scores[0][3]);//75
//System.out.println(scores[0][4]);//java.lang.ArrayIndexOutOfBoundsException: 4
}
}
7.5 二维数组的遍历
for(int i=0; i<二维数组名.length; i++){ //二维数组对象.length
for(int j=0; j<二维数组名[i].length; j++){//二维数组行对象.length
System.out.print(二维数组名[i][j]);
}
System.out.println();
}
public class Test23TwoDimensionalArrayIterate {
public static void main(String[] args) {
//存储3个小组的学员的成绩，分开存储，使用二维数组。
int[][] scores = {
{85,96,85,75},
{99,96,74,72,75},
{52,42,56,75}
};
System.out.println("一共有" + scores.length +"组成绩.");
for (int i = 0; i < scores.length; i++) {
System.out.print("第" + (i+1) +"组有" + scores[i].length + "个学员，成绩如下：");
for (int j = 0; j < scores[i].length; j++) {
System.out.print(scores[i][j]+"\t");
}
System.out.println();
}
}
}