java学习笔记（不定时更新~）

学习Java目前建议的书籍：《21天学通java》、《30天学通Java项目案例开发》>、《Java核心技术 卷I》、《Java核心思想》

学习J2EE方面的知识：《21天学通JavaWeb开发》、《30天学通JAVAWEB项目开发》（均为电子工业出版社出版图书）

目前在看的书籍为《疯狂Java讲义》——电子工业出版社的

第三章 数组

3.1 数组的基础知识

动态初始化： 数组的声明创建与数组的赋值操作分开进行

​ 元素的下标可以是整型常量或整型表达式：数组名【元素下标】=元素值;

​ 动态初始化实例：int [] scores = new int[5];
动态初始化只指定数组的长度，且系统为每个数组元素指定初始值。动态初始化的语法格式如下：

arrayName = new type[length];

以下为一个数组动态化的实际编程案例

//计算班级的平均分
import java.util.*;

public class test {
    public static void main(String[] args) {
        int [] score = new int[5];
        int sum = 0;			//成绩总和
        Scanner input  = new Scanner(System.in);
        System.out.println("请输入五名同学的成绩：");
        for(int i=0;i<score.length;i++) {		//注意定义代码的可复用性
            score[i] = input.nextInt();
            sum+=score[i];
        }
        double avg = (double)sum / score.length;
        System.out.println("The average score is:"+avg);

    }
}

• 使用数组常见的错误：
• int[] score = new int[]; //编译出错，没有指明数组的维度
• 数组越界问题

3.2 数组排序

问题：循环录入5位学员的成绩，进行升序排列后输出结果

​ java提供了很多工具类，例如:

​ Arrays.sort(数组名); //Arrays类的sort()方法：对数组进行升序排列

​ 更多常见的数组方法见下图：

注意：比较两个数组是否相等不能用==，要用equals方法，Java中==比较的是地址，结果一定为false

常使用的方法：sort、equals、binarySearch

3.4 二维数组的声明

二维数组的声明类型：

• 数组类型 数组名【】【】
• 数组类型【】【】 数组名
• 数组类型【】 数组名【】

二维数组的创建

​ 数组名 = new 数据元素类型【行数】【列数】；

​ 数组名 = new 数据元素类型【行数】【】；

​ 注意：必须声明行的个数！！！ 行的数量不可缺省，会产生语法错误

//二维数组的动态初始化
int[][] a = new int[3][];

a[0] = new int[2];
a[1] = new int[3];
a[2] = new int[4];

​ 重点：二维数组的动态定义、二维数组的内外层循环方法

章节案例：用二维数组模拟五子棋游戏

//未添加判断输赢的规则，将会在之后完善并发出
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Gobang {
    //定义棋盘的大小
    private static int BOARD_SIZE = 15;

    //定义一个二维数组来充当棋盘
    private String [][] board;

    public void initBoard(){
        //初始化棋盘空间
        board = new String[BOARD_SIZE][BOARD_SIZE];

        for(int i=0;i<BOARD_SIZE;i++){
            for (int j=0;j<BOARD_SIZE;j++){
                board[i][j] = "+";
            }
        }
    }

    //在控制台输出棋盘的方法
    public void printBoard(){
        //打印每一个数组元素
        for(int i=0;i<BOARD_SIZE;i++){
            for (int j=0;j<BOARD_SIZE;j++){
                System.out.print(board[i][j]);
            }
            System.out.println();
        }
    }

    public static void main(String[] args) throws Exception{
        Gobang gb = new Gobang();

        gb.initBoard();
        gb.printBoard();

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String inputStr = null;

        while((inputStr = br.readLine()) != null){
            String [] postStrArr = inputStr.split(",");

            int xPos = Integer.parseInt(postStrArr[0]);
            int yPos = Integer.parseInt(postStrArr[1]);

            gb.board[xPos-1][yPos-1] = "·";

            gb.printBoard();
            System.out.println("请输入您下棋的坐标，应该以x，y的格式输入：");
        }
    }
}

第四章 在线订餐系统

代码内容后续将单独以博客的形式推出，敬请期待~

第五章 类和对象

5.1 类和对象的定义

​ 面向对象的思想（OOP，Object Oriented Programming）的三个特征

• 封装
• 继承
• 多态

​ 类的定义：修饰符一般为public，也可以没有修饰符

​ 注意类名的命名规范。类名一般大写。

​ 类的成员：

​ 成员变量（属性）、成员函数（方法）

​ 通过 “.”调用属性和方法

5.2 创建类和对象

问题：一个景区根据游人的年龄收取不同价格的门票。请编写游人类，根据年龄段决定能够购买的门票价格并输出

5.3 类的方法

​ 构造方法

• 具有与类相同的名称
• 不含返回值类型
• 不能在方法中用return语句返回一个值
• 一般访问权限位public

​ 在一个类中，具有上述特征的我们就可以成为对象方法

​

​ 构造方法的作用：

• 完成对象的创建，即完成对象的实例化
• 一般使用构造方法来完成对成员变量的初始化

对象的创建

语法格式：

​ 类名 对象名 = new 构造函数

示例：Employee zhang = new Employee()

方法的重载（overload）

​ 函数的重载就是在同一个类中允许同时存在一个以上同名的函数

方法重载的规则

• 函数名称相同
• 函数的参数必须不同（参数个数不同 或 参数类型不同）
• 函数的返回值类型可以相同，也可以不同

5.4 类的属性

变量的作用域

​ 全局变量

​ 类体中声明的成员变量为全局变量

​ 全局变量在类的整个生命周期中都有效

​ 局部变量

​ 方法体中声明的变量，方法中的参数，或代码块中声明的变量，都是局部变量

​ 局部变量只在方法调用的过程中有效，方法调用结束后失效

5.5 类的封装

面向对象三大特征之一 ——封装

​ 封装的概念：将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

​ 数据是存储的内容，而方法是对这样的数据的一个操控。

​ 封装的好处：隐藏类的实现细节、方便加入控制语句、方便修改实现、只能通过规定方法访问数据

封装的步骤：修改属性的可见性->创建共有的getter和setter方法（使用Eclipse软件即可对类中的方法添加重构）->在getter和setter方法中加入属性控制语句（对属性值的合法性进行判断）

第六章 继承

6.1 定义继承关系

子类继承父类使用的是extends to关键字，在子类中重定义父类中的构造函数的方法为：

class PersonalDept extends DepartMent{
    //子类对父类的继承关系
}

public PersonalDept(String name,String manager,String responsibility,int count){
    super(name,manager,responsibility);
    this.count = count;
}

使用super函数即可调用父类中的构造函数方法，然后继续增加子类中的声明内容即可；

• 在Java中定义一个类时，让该类通过关键字extends继承一个已有的类
• 被继承的类称为父类（超类、基类），新的类称为子类（派生类）
• 子类继承父类的所有属性、方法，同时也可以增加自己的属性和方法

6.2 类方法的重写

继承的规则：

​ Java中只支持单继承，也就是说每个类只能有一个父类，不允许有多重继承

​ 一个父类可以有多个子类

​ 子类继承父类的所有属性和方法，但不继承父类的**构造方法 **，要用super关键字调用父类的构造方法。

class Dog extends Pet{
    //子类特有的属性和方法
}

子类访问父类成员

• 访问父类构造方法

  super();		//在子类构造方法中调用，且必须是第一句
  super(name);
  

• 访问父类属性

super.name();

• 访问父类方法

super.print();

子类在重写父类的方法时要在上一行加上@Override

@Override
public void printDetail(){
    super.printDetail();
    System.out.println("本月计划招聘人数："+count);
}

方法的覆盖（override）【Java中的写法： @Override】

· 重写（rewrite）

· 对从父类中继承来的方法进行改造

· 在子类继承父类的时候发生

​ 注意覆盖（override 父类和子类）和重载（overload 在同一个类）是不一样的

方法覆盖的规则：

在子类中的覆盖方法与父类中被覆盖的方法应具有

​ 相同的方法名

​ 相同的参数列表（参数数量、参数类型、参数顺序都要相同）

​ 相同的返回值类型

​ 子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限

6.3 Object类

​ Object类是所有类的父类

第七章 多态

7.1 多态的实现

多态意味着在一次方法调用中根据包含的对象的实际类型（即实际的子类对象）来决定应该调用哪个方法，而不是由用来存储对象引用的变量来决定的。当调用一个方法时，为了实现多态的操作，这个方法既是在父类中声明的方法，也必须是在子类中重写过的方法。

public class Test{
    public static void main(String[] args){
        Pet pet;
        pet = new DOg();
        pet.toHospital();		//狗狗看病
        
        pet = new Bird();
        pet.toHospptal();		//小鸟看病
    }
}

按照上述方式书写代码存在的问题：会造成代码冗余、工作量大