java学习第一周（基础学习）

主讲内容：

java基础语法---关键字、标识符、数据类型；

面向对象的初步---类的构成；

变量的分类；

构造器的作用；

Java基础语法

            关键字：在java中一些用作于特殊用途的英文单词，称之为关键字，所有的关键字全部都是小写；goto和const还未被启动，所以在java中主要作为保留字存在。

            标识符：java中凡是可以由程序员自己命名的元素统一称为标识符。

                          标识符有四种：

                                               1.包标识符：全部小写

                                               2.类名标识符：首字符大写，如果由多个单词构成，每个单词的首字符都大写；

                                              3.方法名和属性名：单个单词是首字母小写；多个单词组成标识符时，首个单词首字母小写，其余单词首字母大写

注意：

标识符命名规范

1.  见名知意

2. 一般使用驼峰式命名规范

   1. 类名称首字符大写，如果由多个单词构成，每个单词的首字符都大写

   2. 属性名和方法名，首字符小写，如果由多个单词构成，除第一个单词外，每个单词首字符都大写

   3. 包名称全部小写

3. 特殊符号除了$、_ 以外其他都不支持

4. 可以使用中文命名，但是一定避免

5. 禁止使用关键字作为标识符

6. 不允许以数字开头，数字可以在中间和末尾

7. 标识符之间不允许包含空格

数据类型

java是一门强类型语言（区别于弱类型语言：javascript），所有的变量或者常量在声明时必须显式的指定数据类型，数据类型一旦定义则无法修改，java中包含两大类数据类型:

1. 基本数据类型(简单类型)

   1. 整数型(byte-1字节、short-2字节、int-4字节、long-8字节)

   2. 浮点型(float-4字节、double-8字节)

   3. 字符型(char-2字节)

   4. 布尔型(boolean-1bits)

2. 引用数据类型(复合类型)

   1. 类的引用

   2. 数组的引用

   3. 接口的引用

数据类型转换

java中的基本数据类型除了boolean以外，其他类型相互之间都可以实现转换，转换规则:

• 小转大，直接转(隐式转换)

• 大转小，强制转(显式转换)

面向对象初步-类的构成

java中万事万物皆对象

类(Class):对一些具备相同特征(属性，行为)的事物的抽象描述

对象(Object):类中的一个实例

类的语法结构

[<修饰符>] class 类名称{

​ //属性的声明

​ //方法的声明(行为)

}

属性（Field）语法:

属性一般表示为类的相关数据信息

[<修饰符>] 数据类型 变量名称 [<=默认值>]

方法（Method）语法

由一些用于完成某些特定逻辑的代码片段构成，方法的主要作用一般也是操作数据

[<修饰符>] 返回值类型 方法名([<参数列表>]){

​ //执行体

}

java中主要包含四种类型方法:

1. 无参数无返回值方法

2. 有参数无返回值方法

3. 无参数有返回值方法

4. 有参数有返回值方法

注意事项:

一个java文件中只能存在一个public的类，若有多个public类，则这些类应该作为内部类存在；通常public类的名称作为java文件名

变量

变量是java中用于描述数据的最基本单元，java中主要包含两种类型变量

1. 成员变量(实例变量)：一般定义在类中与方法同一个级别，使用范围为整个类的内部元素(普通方法，构造器，语句块)；成员变量有默认值(具体值由数据类型决定)

2. 局部变量:一般定义在方法内部，或者语句块内部，作用范围只能是定义区域以及其子区域

构造器(Constractor)

 

构造器也叫构造方法，构造函数，构造器是一个特殊的方法，在java中对象的创建必须通过构造器完成，构造器的名称一般跟类名称保持一致（包括大小写），构造器没有任何的返回值类型（包括void），任何一个java类中都存在一个默认的无参构造器；构造器一般用于对成员变量初始化或者完成一些资源的开启操作等

一个类中可以存在多个构造器，但是每个构造器必须保证方法的参数个数，顺序，类型至少有一项不一致(方法的重载:overload)

7.11

    

• 流程控制

• 数组

在java中程序的执行通常包含三种结构

1. 顺序结构(从main方法开始，从上往下依次执行)

2. 分支结构

   1. if...else...

   2. switch

3. 循环结构

分支结构（条件分支）

if...else...

语法结构:

if(条件表达式){

​ //执行体

}

if(条件表达式){

}else{

}

if(条件表达式){

}else if(条件表达式){

}else{

}

switch

语法：

switch(变量){

case 值1:

​ //执行内容 break;

case 值2：

​ //执行内容 break;

...

default:

​ //执行内容 break;

}

switch能够支持的数据类型包含:

1. 整数:byte short int

2. 字符:char

3. 字符串:String （JDK1.7+）

4. 枚举类型(enum ：JDK1.5+)

循环语句

1. for循环

2. while循环

3. do...while循环

4. forEach循环(主要用于数组或者集合遍历操作，迭代)

5. 递归（recursion）

for循环

语法：

for(初始变量;条件表达式;步进表达式){

​ //循环体

}

while循环

语法:

while（条件表达式）{

​ //循环体

}

do...while循环

语法

do{

​ //执行体

}while(条件表达式)

打断循环

• continue：跳过循环语句中的一次循环

• break：在循环语句中可以用于结束一层循环

• return: 用于表示方法的结束，一旦执行到return，则方法结束；在同一个代码片段中return之后不允许执行任何其他代码

递归（Recursion）

递归即在方法内部调用方法自身，递归可以解决一些算法问题(斐波拉契数列等)，文件夹遍历问题（目录树）、菜单树等结构，在java中递归有两种模式:

1. 直接递归

2. 间接递归

数组

数组是用于存储一组相同数据类型的数据结构，数组是一种引用数据类型。

数组的声明语法:

数据类型[] 变量名；

数组的初始化：

1. 静态初始化

2. 动态初始化

//数组静态初始化
int[] i = {1,3,5,7,9,11};
​
//数组的动态初始化
int[] j = new int[5];
int[] i = {1,3,5,7,9,11};
​
//数组的动态初始化
int[] j = new int[5];

数组中的元素获取方式通过索引，数组的索引从0开始；在获取数组中的元素时索引值是从0~（数组的长度-1）

数组的长度一旦定义无法改变

7.12

• 复合类型数组

• 动态数组-ArrayList

复合类型数组

java中的数组除了可定义基本类型数组，String类型数组外同时也能声明自定义类型数组，比如:

Student[] stus = new Student[5];

 

 

User[] users = {u1,u2,u3,u4...}

ArrarList动态数组

由于数组为定长数据结构，通常数组一旦定义，则长度无法修改，在实际使用中往往存在不够灵活的缺点；因此、在java中存在一种长度可变的动态数组:ArrayList，ArrayList类是基于可变长度数组的实现，底层实现原理依然是数组，内部通过数组拷贝的方式实现了数组的长度可变，ArrayList中提供了一系列用于操作数组中元素的方法，例如:

• size() 获取ArrayList中元素的个数

• add() 向ArrayList中添加新元素

• get() 获取指定索引处的元素

• remove() 删除指定索引处的元素

• clear() 清除数组中的所有元素

• ...

注意事项:

ArrayList若不指定泛型(参数化类型)时，可以向数组中添加任何数据类型；一旦指定泛型，则ArrayList内部的元素会限定只能存储与泛型一致的数据类型

7.13

• 二维数组

• 面向对象-封装

二维数组

可以将数组作为另个数组的元素，即数组中的数组（二维数组，三维数组）

int[][] i = new int[3][3]int[][][] j = new int[3][3][3]

面向对象-封装

面向对象语言通常包含三大特征:

1. 封装

2. 继承

3. 多态

其中封装(信息隐藏)是对对象的一种保护机制，通过将对象的属性或者方法设置为private，从而使得外界不能通过对象轻易访问器属性或方法，封装即将对象的属性和行为捆绑为一个逻辑单元，并将对象的属性设置为私有，通过公开的方法对其进行操作，从而有效避免外界未经授权而直接操作属性数据(可能会带来一些安全性问题)

7.14

• 类之间的关系

• 继承

• 方法重写

• this & super

• 访问控制

• Object

    

类之间关系

横向关系

1. 依赖关系

2. 关联关系

3. 组合关系

4. 聚合关系

纵向关系

1. 继承关系

2. 实现关系

依赖关系

某个对象在执行指定方法时需要其他类的对象参与完成

public class Cup {
​
    private int cno;        //编号
    private String color;   //颜色
    private double capacity;//容量
    
}
​
class People {
​
    public void p(String msg){
        System.out.println(msg);
    }
    
    public void drink(Cup c){
        
    }
} class Cup {
​
    private int cno;        //编号
    private String color;   //颜色
    private double capacity;//容量
    
}
​
class People {
​
    public void p(String msg){
        System.out.println(msg);
    }
    
    public void drink(Cup c){
        
    }
}

继承

继承是面向对象语言的三大特征之一，通过继承关系可以实现方法和属性的复用，从而提高类的可扩展性，子类继承父类之后，可以不受限制的使用父类中的非私有（private）元素继承语法:

class A extends B{

}

继承注意事项

1. java只能存在单继承，即:一个子类只能有一个直接父类

2. 可以通过多重继承的方式实现多个父类方法复用

3. java中的类可以同时被多个子类继承

4. 子类继承父类后可以使用父类中的方法和属性，但是构造器不允许继承

5. 在构造子类对象时，先调用父类构造器

访问权限

1. public

2. protected

3. default(默认不写)

4. private

 

关于访问修饰符：

对外部类只能使用public或者默认的方式修饰，不予许使用private或者protected（内部类除外）

类,方法常用public修饰

属性常用private修饰

继承关系中方法常用protected，public修饰

多态实现策略-方法的重写（Override）与重载(Overload)

重写

在某些情况下父类中的方法不一定能够完全满足子类需求，此时，子类中可以通过对父类的方法覆盖从而完成另一种方法实现，这个操作就称之为方法重写(override)

方法重写

1. 方法的重写发生在存在继承关系的两个类中子类

2. 子类在重写方法时方法名称必须保持与父类一致(包括大小写)

3. 子类重写父类方法时返回值类型必须保持跟父类一致

4. 子类重写父类方法时参数列表必须保持与父类方法参数列一致

5. 子类重写父类方法时，方法的访问权限范围不能小于父类方法

Object类

所有的Java类都直接或者间接继承了Object,Object类中为子类提供了一些用于重写的方法（比如,toString、equals、hashcode等），以实现子类对象之间的操作

 

==和equals区别

==是一个比较运算符，在进行基本数据类型比较时，比较的是两个数据的值，在比较两个引用时，比较的是两个对象的内存地址；equals是Object类的一个方法，默认的实现使用的是==，可以在子类中通过对equals方法重写以达到自定义的比较目的；在比较基本类型数据是否相等时使用:==,在比较引用类型是否相等时需要重写equals方法，并用其实现比较(一般在重写equals方法时同时应该对hashcode方法重写，以保证两个对象的hash值一致)

 

this&super

this:

在java中每一个类都存在一个this对象，该this对象表示为当前类的一个实例，可以在类的内部通过this调用当前类自身的其他构造器，方法以及属性，this关键字只允许出现在普通方法（实例方法）和构造器中；

super：

super表示父类的实例，在子类中可以通过super关键字调用父类中的属性，构造器与方法