JAVA语言基础：数组 | 方法的递归 | 面向对象

数组

数组的基本概念

什么是数组

  数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
  数组既可以存储基本数据类型，也可以存储引用数据类型

数组的定义格式

  格式1： 数据类型[] 数组名；
  格式2： 数据类型   数组名[];
  例如：
  int[] a； 	定义了一个int类型的数组a；
  int a[];	定义了一个int类型的a数组；
  推荐使用第一种定义方式。

数组的初始化

什么是数组的初始化

  Java中的数组必须先初始化,然后才能使用。
  所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

初始化的分类

   a:动态初始化:	只指定长度，由系统给出初始化值
   b:静态初始化:	给出初始化值，由系统决定长度	
   注意事项： 这两种方式，只能使用一种，不能进行动静结合	

动态初始化

   数据类型[] 数组名 = new 数据类型[数组长度];
   数组长度其实就是数组中元素的个数。
  举例： int[] arr = new int[3];	
  定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。

静态初始化

  格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
	举例： int[] arr = new int[]{1,2,3};
  简化格式：
	数据类型[] 数组名 = {元素1,元素2,…};
	举例： int[] arr = {1,2,3};

二维数组

概念

   我们学校的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。
这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用
由此可见：其实二维数组其实就是每一个元素为一维数组的数组。

格式1

 数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选
举例:
	int[][] arr = new int[3][2];
	定义了一个二维数组arr
	这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
	每个一维数组有2个元素，可以通过arr[m][n]来获取
		表示获取第m+1个一维数组的第n+1个元素
C:注意事项
A:以下格式也可以表示二维数组
	a:数据类型 数组名[][] = new 数据类型[m][n];
	b:数据类型[] 数组名[] = new 数据类型[m][n];
	这两种格式不推荐使用
B:注意下面定义的区别
	int x,y;
	int[] x,y[];	
	
	区别是:
	 int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
	  x=new int[3];	
		  y=new int[3][];

格式2

   数据类型[][] 变量名 = new 数据类型[m][];
	m表示这个二维数组有多少个一维数组
	这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：
	int[][] arr = new int[3][];
	arr[0] = new int[2];
	arr[1] = new int[3];
	arr[2] = new int[1];

格式3

   数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
简化版:
	数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
	举例: 
		int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
		int[][] arr = {{1,2,3},{5,6},{7}}；

Java中的内存分配以及栈和堆的区别

A:栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
B:堆: 存放的是所有new出来的东西
特点：
	a: 每一个new出来的东西都会为其分配一个地制值。
	b: 每一个变量都有一个默认的值
		byte，short，int，long  -- 0
		float，double 		       -- 0.0
		char 				      -- '\u0000'
		boolean 				-- false
		引用数据类型	 -- null		
	c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
C:方法区:(面向对象部分讲解)
D:本地方法区:(和系统相关)
E:寄存器:(cpu使用)

内存图解

两个数组的图解
三个数组的图解
二位数组的图解

递归

递归概述: 方法定义中调用方法本身的现象
递归注意事项
要有出口，否则就是死递归
次数不能太多，否则就内存溢出
递归所体现的思想 （拆分与合并）
5的阶乘的内存图解

面向对象

面向对象思想概述

当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，
能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

面向对象的特点

是一种更符合我们思想习惯的思想 懒人思想
可以将复杂的事情简单化 
将我们从执行者变成了指挥者
	角色发生了转换

类与对象

类和对象的概念
  a:类：是一组相关的属性和行为的集合
  b:对象：是该类事物的具体体现
  c:举例：
	        类	    学生
	        对象	班长就是一个对象
定义类其实就是定义类的成员(成员变量和成员方法)
   a:成员变量	和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
   b:成员方法	和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。

成员变量与局部变量

  A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：:	局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

手机类的定义与使用

 A:文件名问题
在一个java文件中写两个类：一个基本的类，一个测试类。
建议：文件名称和测试类名称一致。
B:如何使用呢?
创建对象使用。
C:如何创建对象呢?
格式：类名 对象名 = new 类名();
D:如何使用成员变量呢?
格式：对象名.变量名
E:如何使用成员方法呢?
格式：对象名.方法名(...)
 public class Phone { //手机类
 //成员变量，成员属性  定义在类中方法外
String name="小米";
double price=799;
String color="白色";
//成员方法
public void call(String name){
    System.out.println("给"+name+"打电话");
}
public class MyTest {
public static void main(String[] args) {
    //Phone 类 分析手机类 要哪些属性 ，有哪些功能
    //使用手机类中的属性和功能
    //类是Java中的最小单位
    //类是一个抽象的概念，要使用类中的方法和属性，得创建该类对象
    Phone phone = new Phone();
    System.out.println(phone.name);
    System.out.println(phone.price);
    System.out.println(phone.color);
    phone.call("张曼玉");
    phone.sendMsg("林青霞","你好");
}
}

匿名对象

 A:什么是匿名对象
就是没有名字的对象
B:匿名对象应用场景
a:调用方法，仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递

封装

 A:封装的引入
通过学生案例，给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。
B:封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
C:封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
D:封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。

private和this关键字的使用

private

 A:private最常见的应用：
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法

this

  A:为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
B:this关键字特点
是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁
C:this的应用场景
解决局部变量隐藏成员变量

标准的电脑类代码及其测试

 电脑类  
public class computer {
private String name;
private int price;
private String xt;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getPrice() {
    return price;
}
public void setPrice(int price) {
    this.price = price;
}

 public String getXt() {
    return xt;
}
public void setXt(String xt) {
    this.xt = xt;
}
public void zy(){
    System.out.println("办公");
}
测试
public void play(String yl){
    System.out.println("玩"+yl+"游戏");
public class test {
public static void main(String[] args) {
    computer computer = new computer();
    computer.setName("DELL");
    computer.setXt("Windows 10");
    computer.setPrice(5000);
    System.out.println(computer.getName());
    System.out.println(computer.getXt());
    System.out.println(computer.getPrice());
    computer.zy();
    computer.play("天涯明月刀");
}
}

测试结果

附录

数组案例演示
将下面的数组元素前后互换
[11, 32，55, 47，79，23]
置换后的数组元素为：
[23, 79, 47, 55, 32, 11]
public class test2 {
public static void main(String[] args) {
int[] a={11,32,55,47,79,23};
for (int i=0;i<a.length/2;i++){
int b=a[i];
a[i]=a[a.length-1-i];
a[a.length-1-i]=b;
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
}

在数组中 查询数据55第一次出现的位置,打印第一次出现的位置
[11, 32，55, 47，55, 79，23]
public class test5 {
public static void main(String[] args) {
int[] a={11,32,55,47,55,79,23};
Scanner sc=new Scanner(System.in);
System.out.println(“请输入一个数”);
int n = sc.nextInt();
int Index=getIndex(n,a);
System.out.println(Index);
}
public static int getIndex(int n,int[] a) {
for (int i = 0; i < a.length; i++) {
if (n == a[i]) {
return i;
}
}
return -1;
}
}