数组相关

和Python中一样, Java中也是有用来同时存储多个同类型元素的容器的, 那就是: 数组. 在一个数组中，数据元素的类型是唯一的，即一个数组中的元素的类型相同。

定义数组

  • 方式一: 动态初始化 (我们给定长度, 由系统给出默认初始化值)
1
2
3
4
5
格式一: 
	数据类型[] 数组名 = new 数据类型[长度];

格式二:
	数据类型 数组名[] = new 数据类型[长度];

解释: 上述两种定义方式只是写法不同, 并无其他区别

  • 方式二: 静态初始化(我们给定初始化值, 由系统指定长度)
1
2
3
4
5
格式一:
	数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3};		

格式二:
	数据类型[] 数组名 = {元素1, 元素2, 元素3};

解释: 上述两种定义方式只是写法不同, 并无其他区别.

数组中的默认值

1
2
3
4
5
例如:
int类型数组, 元素默认值是: 0
double类型的数组, 元素默认值是: 0.0
boolean类型的数组, 元素默认值是: false
String类型的数组, 元素默认值是: null

基本使用

  • 1- 通过数组名[索引]的形式, 可以快速获取数组中的指定元素
1
2
3
4
5
6
格式: 
	数组名[索引]

例如:
int[] arr = {11, 22, 33};
System.out.println(arr[0]);	//打印结果是: 11
  • 2- 通过数组名[索引] = 值;的方式, 可以修改数组中的指定元素值.
1
2
3
4
5
6
7
8
格式: 
	数组名[索引] = 值;

 //例如:
int[] arr = {11, 22, 33};
System.out.println(arr[1]);	//打印结果是: 22
arr[1] = 222;
System.out.println(arr[1]);	//打印结果是: 222
  • 3- 通过数组名的length方法, 可以获取数组的长度
1
2
3
4
5
6
格式:
	数组名.length

例如:
int[] arr = {11, 22, 33};
System.out.println(arr.length);	//打印结果是: 3

数组的内存图介绍

内存是计算机中的重要原件，也是临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

即: Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

JVM的内存划分

1
2
3
4
5
6
7
8
9
10
11
1.栈: 存储局部变量以及所有代码执行的. 
	局部变量: 指的是定义在方法中, 或者方法声明上的变量. 
	特点: 先进后出. 
2.堆: 存储所有new出来的内容(即: 对象).
	特点: 堆中的内容会在不确定的时间, 被GC回收. 
3.方法区: 存储字节码文件的.
	字节码文件: 指的是后缀名为.class的文件. 
4.本地方法区:
	和系统相关, 了解即可. 
5.寄存器
	和CPU相关, 了解即可.

数组的内存图

1
2
3
4
5
6
7
8
9
public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arr = new int[3];
		//打印数组中的第一个元素, 值为: 0
        System.out.println(arr[0]);	
		//[I@1540e19d
        System.out.println(arr);
	}
}

数组的两个小问题

数组是我们在实际开发中用到的比较多的容器, 在使用它的时候, 很可能会遇到如下的两个问题:

  • 1- 数组索引越界异常(ArrayIndexOutOfBoundsException)
1
2
产生原因: 访问了数组中不存在的索引. 
解决方案: 访问数组中存在的索引即可.
  • 2- 空指针异常(NullPointerException)
1
2
产生原因: 访问了空对象. 即: 对象为空, 你还去调用它的一些方法, 肯定不行. 
解决方案: 对对象赋具体的值即可.

数组的常见操作

数组是我们在实际开发中用到的比较多的一种容器, 它的常见操作如下:

  • 遍历数组.
  • 获取数组的最值(最大值, 或者最小值).
  • 反转数组.
1
2
3
4
5
6
7
8
//前面两个就不说了,非常简单,说说反转数组吧
int[] arr = {1, 2, 3, 4, 5};
// 数组长度为5需要交换两次, 数组长度为6需要交换3次 -> 循环次数为arr.length/2 次
for(int i = 0; i < arr.length/2; i++){
		    int tmp = arr[0];
		    arr[0] = arr[arr.length - i -1];
	    arr[arr.length - i -1] = tmp;
}

方法相关

Python中的函数, 是将具有独立功能的代码块组织成为一个整体，使其成为具有特殊功能的代码集.

Java中也是如此, 只不过, Java中的函数也叫方法.

定义格式

修饰符 返回值的数据类型 方法名(参数类型 参数名1, 参数类型 参数名2) { //这里可以写多个参数
//方法体;
return 具体的返回值;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

修饰符: 目前记住这里是固定格式public static

返回值的数据类型: 用于限定返回值的数据类型的.
	注意: 
		1.返回值的数据类型是int类型, 则说明该方法只能返回int类型的整数.
		2.如果方法没有具体的返回值, 则返回值的数据类型要用void来修饰.

方法名: 方便我们调用方法.  定义的时候 要遵循小驼峰的命名法

参数类型: 用于限定调用方法时传入的数据的数据类型.
	例如: 参数类型是String类型, 说明我们调用方法时, 只能传入字符串.
        
参数名: 用于接收调用方法时传入的数据的变量. 
    
方法体: 完成特定功能的代码.
    
return 返回值: 用来结束方法的, 并把返回值返回给调用者. 
	解释: 如果方法没有明确的返回值, 则return关键字可以省略不写.

注意事项:

1
2
3
4
5
6
7
8
1.方法与方法之间是平级关系, 不能嵌套定义.
2.方法必须先创建才可以使用, 该过程称为: 方法定义.
3.方法自身不会直接运行, 而是需要我们手动调用方法后, 它才会执行, 该过程称为方法调用.
4.方法的功能越单一越好. 
5.定义方法的时候写在参数列表中的参数, 都是: 形参. 
	形参: 形容调用方法的时候, 需要传入什么类型的参数.
6.调用方法的时候, 传入的具体的值(变量或者常量都可以), 叫实参. 
	实参: 调用方法时, 实际参与运算的数据.

方法重载

定义: 同一个类中, 出现方法名相同, 但是参数列表不同的两个或以上的方法时**称为方法重载. **方法重载与方法的返回值的数据类型无关.

1
2
3
注意: 参数列表不同分为两种情况
1.参数的个数不同.
2.对应参数的数据类型不同.

面向对象

和Python一样, Java也是一门以面向对象为编程思想的语言, 也有类, 对象的概念, 并且面向对象的三大特征: 封装, 继承, 多态, 在Java中也都是有的, 接下来, 我们来研究下Java中的面向对象应该如何运用.

类的定义与使用

定义类其实就是定义类的成员(成员变量和成员方法)

  • 成员变量:
    • 1- 和以前定义变量是一样的, 只不过位置发生了改变, 写到类中, 方法外
    • 2- 而且成员变量还可以不用赋值, 因为它有默认值.
  • 成员方法:
    • 1- 和以前定义方法是一样的, 只不过把static关键字去掉.
    • 2- 这点先记忆即可, 后面我们再讲解static关键字的用法.

定义类的格式

1
2
3
4
5
6
public class 类名 {
//成员变量, 私有化, 类似于Python中的 __
//构造方法, 空参, 全参, 类似于Python的魔法方法之 __init__(self)
//getXxx(), setXxx()方法, 用来获取或者设置对象的属性值的
    //成员方法, 就是普通的函数
}

使用类中成员的格式:

1
2
3
4
5
6
7
8
1.创建该类的对象, 格式如下: 
 类名 对象名 = new 类名();
2.通过对象名.的形式, 调用类中的指定成员即可, 格式如下: 
 //成员变量
 对象名.成员变量

 //成员方法
 对象名.成员方法(参数列表中各数据类型对应的值...)

构造方法

Java中的构造方法类似于Python中的魔法方法之_init_(), 就是用来创建对象的, 捎带着可以给对象的各个成员变量赋值.格式:

  • 1.构造方法名必须和类名完全一致(包括大小写).
  • 2.构造方法没有返回值类型, 连void都不能写.
  • 3.构造方法没有具体的返回值, 但是可以写return(实际开发, 一般不写).
1
2
3
public 类名(参数类型 参数名1, 参数类型 参数名2) {  //这里可以写多个参数.
    //给对象的各个属性赋值即可.
}

相关的注意事项:

1
2
3
4
1.如果我们没有给出构造方法, 系统将给出一个默认的无参构造供我们使用. 
2.如果我们给出了构造方法, 系统将不再提供默认的构造方法给我们使用. 
	2.1 这个时候, 如果我们还想使用无参构造, 就必须自己提供.
        2.2 建议定义类时,我们给出无参构造, 方便用户调用(实际开发都这么做的).

封装

封装是面向对象编程思想的三大特征之一, 所谓的封装指的就是隐藏对象的属性和实现细节, 仅对外提供一个公共的访问方式.

记忆:

面向对象的三大特征: 封装, 继承, 多态.

1
2
3
4
5
6
7
问题一: 怎么隐藏?

答案: 通过private关键字实现.

问题二: 公共的访问方式是什么?

答案: getXxx()和setXxx()方法

可能涉及的相关特殊关键词:

  • private关键字
1
2
3
4
5
6
7
8
private是一个关键字, 也是访问权限修饰符的一种, 它可以用来修饰类的成员(成员变量和成员方法).

特点: 
	被private修饰的内容只能在本类中直接使用.

应用场景:
	1.在实际开发中, 成员变量基本上都是用private关键字来修饰的.
	2.如果明确知道类中的某些内容不想被外界直接访问, 都可以通过private来修饰.
  • this关键字
1
2
3
4
5
this代表本类当前对象的引用, 大白话翻译: 谁调用, this就代表谁. 

作用:
	用来解决局部变量和成员变量重名问题的.
    类似于python中 self 关键词

继承

多个类中存在相同属性和行为时, 将这些内容抽取到单独的一个类中, 那么这多个类就无需再定义这些属性和行为了, 只要继承那个类即可. 这个关系, 就叫继承, Java中, 类与类之间的继承只能单继承,不能多继承,但是可以多层继承.

  • 格式
1
2
3
4
5
6
7
8
9
格式:
public class 类A extends 类B {	//子承父业
    
}

解释:
类A: 叫子类, 或者派生类.
类B: 叫父类, 基类, 或者超类.
我们一般会念做: 子类和父类.

继承的好处弊端

说明: 继承的好处和弊端

1
2
3
4
5
6
7
8
9
10
11
好处:
    1.提高了代码的复用性.
    2.提高了代码的可维护性.
    3.让类与类之间产生关系, 是多态的前提. 
   
弊端:
	让类与类之间产生了关系, 也就让类的耦合性增强了. 
    解释:
		开发原则: 高内聚, 低耦合.
		内聚: 指的是类自己独立完成某些事情的能力.
		耦合: 指的是类与类之间的关系.

方法的重写:

子类中出现和父类一模一样的方法时, 称为方法重写. 方法重写要求返回值的数据类型也必须一样

1
2
什么时候需要使用方法重写:
	当子类需要使用父类的功能, 而功能主体又有自己独有需求的时候, 就可以考虑重写父类中的方法了, 这样, 即沿袭了父类的功能, 又定义了子类特有的内容.

注意事项:

1
2
3
1.子类重写父类方法时, 方法声明上要用@Override注解来修饰. 
2.父类中私有的方法不能被重写. 
3.子类重写父类方法时, 访问权限不能更低.

多态

多态指的是同一个事物(或者对象)在不同时刻表现出来的不同状态.

多态的使用前提

1
2
3
4
多态使用的前提条件:
1.要有继承关系.
2.要有方法重写.
3.要用父类引用指向子类对象.

多态的好处和弊端

1
2
3
4
5
6
好处: 提高了程序的扩展性. 

弊端:
父类引用不能访问子类的特有功能. 
问:  那如何解决这个问题呢? 
答:  通过向下转型来解决这个问题.

上下转型的方式:

1
2
3
4
5
6
7
8
9
10
11
向上转型:
格式
父类型 对象名 = new 子类型();

例如: Animal an = new Cat();

向下转型:
格式
子类型 对象名 = (子类型)父类引用;

例如: Cat c = (Cat)an;

示例:

1
2
3
4
5
6
7
// 向下转型
Animal animal3 = new Cat();
Cat cat = (Cat) animal3; // 向下转型
Dog dog = (Dog) animal3; // 直接报错(ClassCastException 类型转换异常), 因为本身就不是 Dog类型, 所以无法进行向下转型

cat.seize();
System.out.println(animal3);

说明: 向下转型的目的是为了调用子类中特有的方法

两个关键字final,this

final关键字

1
2
3
4
final是一个关键字, 表示最终的意思, 可以修饰类, 成员变量, 成员方法. 
•修饰的类: 不能被继承, 但是可以继承其他的类. 
•修饰的变量: 是一个常量, 只能被赋值一次. 
•修饰的方法: 不能被子类重写.

static关键字

1
2
3
4
5
6
7
8
static是一个关键字, 表示静态的意思, 可以修饰成员变量, 成员方法. 

特点:
1.随着类的加载而加载.
2.优先于对象存在.
3.被static修饰的内容, 能被该类下所有的对象共享.
	解释: 这也是我们判断是否使用静态关键字的条件. 
4.可以通过类名.的形式调用.

静态方法的访问特点及注意事项

1
2
3
4
5
6
7
访问特点
	静态方法只能访问静态的成员变量和静态的成员方法.
	简单记忆: 静态只能访问静态. 
注意事项
	1.在静态方法中, 是没有this, super关键字的. 
	2.因为静态的内容是随着类的加载而加载, 而this和super是随着对象的创建而存在. 
 		即: 先进内存的, 不能访问后进内存的.

静态代码块: 随着类的加载而加载, 而且只会加载一次

1
2
3
4
5
6
7
格式:
static {


}

一般是放置在类中 方法外