java中事物的状态有哪些,Java基础四

数组原理内存图

为了提高运算效率，就对空间进行了不同区域的划分，因为每一篇区域都有特定的出来数据方式和内存管理方式。

栈的特点：先进后出

JVM的内存划分：

区域名称

作用

寄存器

给CPU使用，和我们开发无关

本地方法栈

JYM在使用操作系统功能的时候使用，和我们开发无关

方法区

存储可运行的class文件

堆内存

存储对象或数组，new来创建的，都存储在堆内存

方法栈

方法运行时使用的内存，比如main方法运行，进入方法栈中执行

1. 输出数组地址

int[] arr = new int[4];

int[] arr2 = new int[3];

System.out.println(arr);

//输出的是数组的地址值 ：[I@1b6d3586

System.out.println(arr2);

//[I@4554617c

ArrayDemo01

2.两个变量指向同一个数组

public class ArrayDemo02 {

public static void main(String[] args) {

//定义数组

int[] arr = new int[3];

//对数组进行赋值操作

for (int i = 0; i < arr.length; i++) {

arr[i]=6;

}

//赋值

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

//定义数组变量arr2，将arr的地址赋值为arr2

int[] arr2 = arr;

//修改arr2的第二个元素为8

arr2[1]= 8;

System.out.println(arr[1]);

}

}

两个变量指向同一个数组

3.数组异常及遍历

(1)数组越界

1.数组下标超出范围

2.数组中没有空间

System.out.println(arr[3]); //ArrayIndexOutOfBoundsException

(2)数组的空指针异常

意味着arr 将不会保存数组的地址了，也就是不允许再操作数组了

arr = null; //NullPointerException

System.out.println(arr[0]);

(3) 数组遍历

for (int i = 0; i < arr2.length; i++) {

System.out.println(arr2[i]);

}

4. 求数组中的最大值

public class ArrayDemo03 {

public static void main(String[] args) {

//创建一个数组

int[] arr = {5, 15, 2000, 10000, 100, 4000};

//求 arr 中最大的值

//定义一个变量，存储输出中最大的值，假设arr中第一个元素是最大的

int max = arr[0];

// 遍历数组，取出每一个元素， 让每一个元素个max进行比较

for (int i = 0; i < arr.length; i++) {

// 遍历元素和max进行比较，如果大于max，就更新max的值

if (arr[i] > max)

max = arr[i];

//max始终是记录最大的值

}

System.out.println("数组中最大的值是"+ max);

}

}

5. 对数组进行反转

方法一

public static void main(String[] args) {

int[] arr = new int[]{1,2,3,4,5};

int[] arr2 = new int[5];

for (int i = 0; i < arr.length; i++) {

arr2[i] = arr[arr.length-i-1];

}

for (int i = 0; i < arr.length; i++) {

System.out.print(arr2[i] + "\t");

}

}

方法二

public static void main(String[] args) {

int[] arr = new int[]{1,2,3,4,5};

for (int i = 0; i < arr.length/2; i++) {

int temp = arr[i];

arr[i] = arr[arr.length-i-1];

arr[arr.length-i-1] = temp;

}

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i] + "\t");

}

}

方法三

public static void main(String[] args) {

/**

* for (初始化条件1,初始化条件2; 循环条件; 步进运算1,步进运算2)

* 定义 min = 0 最小索引值， max = arr.length-1 最大索引值

*/

int[] arr = new int[]{1,2,3,4,5};

for (int min =0,max = arr.length-1;min <= max; min++ , max--){

int temp = arr[min];

arr[min] = arr[max];

arr[max] = temp;

}

// 重新遍历反转的数组

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i]);

}

}

6.数组作为方法的参数进行传递

public class ArrayDemo05 {

public static void main(String[] args) {

sayHello("韩梅梅");

int[] arr = {1, 3, 5, 7, 9};

printArray(arr);

}

public static void sayHello(String name){

System.out.println("Hello" + name);

}

//之前我们看到的方法都是基本数据类型作为参数的

//使用数组作为方法的参数

// public static void printArray(形参 实参){}

// public static void printArray(数据类型 变量值){}

public static void printArray(int[] arr){

// 想要打印出数组，我们可以使用for循环遍历

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

}

}

对应JVM内存图

数组作为方法的参数传递

7.数组作为方法的返回值

public class ArrayDemo06 {

public static void main(String[] args) {

int[] arr = getArray();

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

}

//void 无返回值

public static int[] getArray(){

int[] arr = {1, 2, 3, 4, 5};

//返回数组的地址，返回给调用者

return arr;

}

}

案例

public class ArrayDemo07 {

public static void main(String[] args) {

int a = 1;

int b = 2;

System.out.println(a);//1

System.out.println(b);//2

change(a, b);

System.out.println(a);//1

System.out.println(b);//2

//change(a,b)没有返回，a,b不变

int[] arr = {1, 3, 5};

System.out.println(arr[0]);//1

change2(arr);

System.out.println(arr[0]);//200

}

public static void change(int a ,int b){

a = a + b;

b = b + a;

// System.out.println(a);

// System.out.println(b);

}

public static void change2(int arr[]){

arr[0] = 200;

}

}

ArrayDemo07

面向对象编程

对象： 泛指现实中一切的事物， 每个事物都有自己的【属性】和【行为】

强调：通过调用对象的行为去实现功能，而不是自己去一步一步实现

举例：洗衣服：

1.面向过程：把衣服脱掉-->盆-->加水-->泡-->洗。。。(强调步骤)

2.面向对象：把衣服脱掉-->打开全自动洗衣机-->放衣服-->开关-->晾衣服(强调对象)

面向对象特点：将复杂的事情简单化，我们从执行者变成了指挥者(完成一个项目花钱雇人完成而不是自己做)

面向对象包含三大基本特征：封装，继承，多态

类和对象

类 : 可以看成一类事物的模板，在面向对象编程中，使用属性和行为来描述类

在现实中:

属性： 该事物的状态信息

行为： 该事物能干什么

对象：是一类事物的具体体现

对象是类的换一个实例，对象就必然具备该类事物的属性和行为

类和对象的关系

类是对一类事物的描述，抽象的

对象是一类事物的实例 具体的

类是对象的模板， 对象是类的实体

类在java中的定义 : 现实中的一类事物

java和现实是一致的

成员变量：对应事物的属性，成员方法：对象事物的行为

成员变量：和之前定义变量一样，只不过位置变了， 在类中，方法外

成员方法：只不过我们要将以前 方法static去掉(static是面向过程的)

public class 类名{

// 成员变量

// 成员方法

//类名使用大驼峰方式

}

类的使用

Java中通过创建对象去使用类

格式：

类名 对象名 = new 类名()

返回值类型 具体的对象名字 = new 类();

我们通过对象去访问类中的成员

对象名.成员变量

对象名.成员方法()

成员变量和全局变量的区别

成员变量和全局变量的区别

成员变量的默认值

成员变量默认值

案例

一.student类

public class Student {

//成员变量：

String name; //姓名

int age; //年龄

//成员方法

//爱学习的方法

public void study(){

System.out.println("Good Good Study,Day Day Up!");

}

//吃饭的方法

public void eat(){

System.out.println("学习饿了就得吃饭");

}

}

//测试类

public class Test01_Student {

//类的使用

//Java中通过创建对象去使用类

//格式：

//类名 对象名 = new 类名()

//返回值类型 具体的对象名字 = new 类();

//我们通过对象去访问类中的成员

//对象名.成员变量

//对象名.成员方法()；

public static void main(String[] args) {

//调用 学生类

//1、创建类：类名 对象名 = new 类名()

Student s = new Student();

//2、打印这个对象

System.out.println(s); //返回包名+16进制地址

//3、访问其中的成员扁蕾

System.out.println("姓名" + s.name);

System.out.println("年龄" + s.age);

//4、给成员变量进行赋值

s.name = "悟空";

s.age = 500;

//5、再次输出变量

System.out.println("姓名" + s.name);

System.out.println("年龄" + s.age);

System.out.println("------------------------");

//6、调用成员方法

s.study();

s.eat();

}

}

二. Phone类

public class Phone {

// 成员变量

String brand; //品牌

int price; //价格

String color; //颜色

//成员方法

//给name打电话

public void Called(String name){

System.out.println("给"+name+"打电话");

}

//发短信

public void SendMessage(){

System.out.println("发短信");

}

}

//测试类

public class Test02_Phone {

public static void main(String[] args) {

//创建对象

Phone p = new Phone();

//输出成员变量

System.out.println("品牌："+ p.brand);

System.out.println("价格："+ p.price);

System.out.println("颜色："+ p.color);

System.out.println("---------------------");

//赋值

p.brand = "华为";

p.color = "green";

p.price = 6666;

//再次输出

System.out.println("品牌："+ p.brand);

System.out.println("价格："+ p.price);

System.out.println("颜色："+ p.color);

System.out.println("---------------------");

//调用方法

p.Called("石浩博");

p.SendMessage();

show(p); //调用show方法

}

// 对象作为参数进行传递

public static void show(Phone p){

System.out.println(p.brand +" "+ p.price+" "+ p.color);

}

}

Phone类对应内存图

面向对象的三大特征

1.封装

封装实际上是将属性封装起来，属性变为私有的，要提供共有的方法对其进行访问

private代表最小权限

可以修饰成员变量和成员方法

被private修饰的成员变量和成员方法，只有在本类才能访问

案例:通过方法访问或改变成员变量

public class StudentInfo {

private String name;

private int age;

//为成员方法提供共有的set, get方法(访问，修改)

public String getName(){

return name;

}

public void setName(String name){

this.name = name;

}

public int getAge(){

return age;

}

public void setAge(int age){

this.age = age;

}

}

this的含义

this代表所在类的当前对象的引用(地址值)，及对象自己的引用

方法被哪个对象调用,方法中的this就代表哪个对象，

即谁在调用，this就代表谁

public class Test03_StudentInfo {

public static void main(String[] args) {

StudentInfo studentInfo = new StudentInfo();

System.out.println(studentInfo.getName());

//调用方法

studentInfo.setName("石浩博");

studentInfo.setAge(21);

//输出

System.out.println(studentInfo.getName());

System.out.println(studentInfo.getAge());

}

}