J2EE | 基础篇 | D05 数组相关、面向对象概念、类的使用及相关练习

数组常见异常求最大最小值

/*
数组的索引编号从0开始，一直到length-1为止。

如果访问数组元素的时候，索引编号并不存在，那么将会发生
数组下标越界异常
ArrayIndexOutOfBoundsException 数组下标越界异常

原因：索引超过范围
解决：修改索引
 */
 
 /*
所有的引用类型变量，都可以赋值为一个null值。代表其中什么都没有。
所有的基本类型变量，都不可以赋值为null值。

数组必须进行赋值（初始化）才能使用其中的元素。
如果只是赋值了一个null，没有进行初始化，
那么将会发生：
空指针异常 NullPointerException

原因：没有初始化
解决：初始化数组
 */
 
 /*
如何获取数组的长度，格式：
数组名.length

这将会得到一个int类型的值，代表数组的长度。

数组一旦创建，程序运行期间，长度不可以改变。
 */
 
 int[] arrayC = new int[3];
 System.out.println(arrayC.length); // 3
 arrayC = new int[5];
 System.out.println(arrayC.length); // 5

遍历数组：依次获取数组的每一号元素。

public class Demo04Array {

    public static void main(String[] args) {
        int[] array = { 15, 25, 30, 40, 50, 60, 75 };

        

     // 使用循环遍历数组，次数其实就是数组的长度。
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"  ");
        }
        System.out.println();
        
        
        for (int i : array) {
			System.out.print(i+"  ");
		}
    }
}

数组中求最大值

    public static void main(String[] args) {
        int[] array = { 5, 15, 30, 20, 10000, 30, 35 };

        int max = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果当前元素，比max更大，则换人
            if (array[i] > max) {
                max = array[i];
            }
        }
        // 谁最后最厉害，就能在max当中留下谁的战斗力
        System.out.println("最大值：" + max);
    }

数组中求最小值

public static void main(String[] args) {
        int[] array = { 5, 15, 30, 20, 10000, -20, 30, 35 };

        int min = array[0]; // 比武擂台
        for (int i = 1; i < array.length; i++) {
            // 如果当前元素，比min更小，则换人
            if (array[i] < min) {
                min = array[i];
            }
        }
        System.out.println("最小值：" + min);
    }

/*
数组元素的反转：
本来的样子：[1, 2, 3, 4]
之后的样子：[4, 3, 2, 1]

要求不能使用新数组，就用原来的唯一一个数组。
 */
public class Demo07ArrayReverse {

	public static void main(String[] args) {
		int[] array = { 10, 20, 30, 40, 50 };

		/*
		 * 初始化语句：int min = 0, max = array.length - 1 条件判断：min < max 步进表达式：min++, max--
		 * 循环体：用第三个变量倒手
		 */
		for (int min = 0, max = array.length - 1; min < max; min++, max--) {
			int temp = array[min];
			array[min] = array[max];
			array[max] = temp;
		}

		// 遍历打印数组
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}
}

数组可以作为方法的参数。

当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };

        System.out.println(array); // 地址值

        printArray(array); // 传递进去的就是array当中保存的地址值

    }

    /*
    三要素
    返回值类型：只是进行打印而已，不需要进行计算，也没有结果，用void
    方法名称：printArray
    参数列表：必须给我数组，我才能打印其中的元素。int[] array
     */
    public static void printArray(int[] array) {
        System.out.println("printArray方法收到的参数是：");
        System.out.println(array); // 地址值
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"  ");
        }
    }

数组作为参数和返回值

/*
一个方法参数个数可以有__个；但是返回值可以有___个，可以有多个返回值吗？。
如果希望一个方法当中产生了多个结果数据进行返回，怎么办？
解决方案：

任何数据类型都能作为方法的参数类型，或者返回值类型。

数组作为方法的参数，传递进去的其实是数组的地址值。
数组作为方法的返回值，返回的其实也是数组的地址值。
 */

面向对象的概念类的创建和使用

//static ： 静态的，如果用static修饰的，就是针对于类
//  			   如果没有static修饰的，就是针对于对象

/*
面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。
 */
 
 /*
通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

1. 导包：也就是指出需要使用的类，在什么位置。
import 包名称.类名称;
import cn.itcast.day06.demo01.Student;
对于和当前类属于同一个包的情况，可以省略导包语句不写。

2. 创建，格式：
类名称 对象名 = new 类名称();
Student stu = new Student();

3. 使用，分为两种情况：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)
（也就是，想用谁，就用对象名点儿谁。）

注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。
 */
 public class Demo02Student {

    public static void main(String[] args) {
        // 1. 导包。
        // 我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写

        // 2. 创建，格式：
        // 类名称 对象名 = new 类名称();
        // 根据Student类，创建了一个名为stu的对象
        Student stu = new Student();

        // 3. 使用其中的成员变量，格式：
        // 对象名.成员变量名
        System.out.println(stu.name); // null
        System.out.println(stu.age); // 0
        System.out.println("=============");

        // 改变对象当中的成员变量数值内容
        // 将右侧的字符串，赋值交给stu对象当中的name成员变量
        stu.name = "赵丽颖";
        stu.age = 18;
        System.out.println(stu.name); // 赵丽颖
        System.out.println(stu.age); // 18
        System.out.println("=============");

        // 4. 使用对象的成员方法，格式：
        // 对象名.成员方法名()
        stu.eat();
        stu.sleep();
        stu.study();
    }

}

/*
定义一个类，用来模拟“学生”事物。其中就有两个组成部分：

属性（是什么）：
    姓名
    年龄
行为（能做什么）：
    吃饭
    睡觉
    学习

对应到Java的类当中：

成员变量（属性）：
    String name; // 姓名
    int age; // 年龄
成员方法（行为）：
    public void eat() {} // 吃饭
    public void sleep() {} // 睡觉
    public void study() {} // 学习

注意事项：
1. 成员变量是直接定义在类当中的，在方法外边。
2. 成员方法不要写static关键字。
 */
public class Student {

    // 成员变量
    String name; // 姓名
    int age; // 年龄

    // 成员方法
    public void eat() {
        System.out.println("吃饭饭！");
    }

    public void sleep() {
        System.out.println("睡觉觉！");
    }

    public void study() {
        System.out.println("学习！");
    }

}

类作为返回值

import com.fs_03面向对象的概念类的创建和使用.Cat;

public class Test {
	public static void main(String[] args) {
		Cat cat = getCatIns();
		System.out.println(cat.name);
		System.out.println(cat.age);
		System.out.println(cat.type);
	}
	
	public static Cat getCatIns() {
		Cat c = new Cat();
		c.name="翠花";
		c.age=18;
		c.type="猫女";
		
		return c;
	}
}

---

相关练习题

1.下列代码的运行结果是什么？

public class Person {
	String name = "张三";
	 int age = 20;
	 public static void main(String[] args) {
	 Person p1 = new Person();
	 p1.info();
	 
	 Person p2 = new Person();
	 p2.name = "小明";
	 p2.age = 22;
	 p2.info();
	 }
	 private void info() {
		 System.out.println(this.name + "今年" + this.age + "岁!");
	 }	
}

张三今年20岁！
小明今年22岁！

2. 定义一个交通工具Vehicle的类，其中有:
   a) 属性：速度speed，类型type等等
   b) 方法：移动move()，设置速度setSpeed(int speed)，加速speedUp(),减速speedDown()等等.
   c) 最后在测试类的main()方法中实例化一个交通工具对象，设定speed,size的值，并且打印出来。另外，调用加速，减速的方法对速度进行改变。

package com.zcl.homework.D05;

public class Vehicle {
	int speed;
	String type;
	
	public void move() {
		
	}
	public void setSpeed(int i) {
		speed = i;
		System.out.println("车速为："+speed);
	}
	public void speedUp() {
		speed += 20;
		System.out.println("加速后速度为："+speed);
	}
	public void speedDown() {
		speed -= 50;
		System.out.println("减速后速度为："+speed);
	}

	//右键resource->Generate toString()
	@Override
	public String toString() {
		return "Vehicle [speed=" + speed + ", type=" + type + "]";
	}
}

package com.zcl.homework.D05;

public class Test {
	
	public static void main(String[] args) {
		Vehicle v = new Vehicle();
		v.setSpeed(200);
		v.speedUp();
		v.speedUp();
		System.out.println(v);
		v.speedDown();
		System.out.println(v);
	}
}

3.自己画出创建数组的内存图
（1）一个引用指向一个数组
（2）两个引用指向同一个数组
理清流程！！

4.谈谈你对static关键字的理解。

被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

static的作用？

• static可以修饰变量，被static修饰的变量叫做静态变量，程序运行时静态变量存放在方法区里面，因此，静态变量在类加载阶段赋值，并且只赋值一次。请看例1
• static可以修饰方法，被static修饰的方法叫做静态方法，不用创建对象就能能直接访问该方法，即使用类名.静态方法名的方式。静态方法不能访问非静态的数据，静态方法不能使用this。请看例2
• static可以定义静态语句块，静态语句块在类加载阶段执行，并且只执行一次，并且是自上而下的顺序执行，在构造方法之前执行。请看例3

static修饰的变量、方法、代码块都是隶属于类(class)级别的,跟对象无关。某一类物体如果可以被多个其他物体所共享，那么可以将这类物体使用static修饰。
比如wifi，多个人可以共同使用同一个wifi，所以wifi可以使用static修饰。手机是每人使用自己的，就不能用static修饰。

例1：

public class StaticTest01 {

    public static void main(String[] args){

        Employee e = new Employee();
        //可以通过对象名.静态方法名的方式访问，工作中不这样使用
        System.out.println(e.company);
        //可以通过类名.静态方法名的方式访问，工作中使用这种写法
        System.out.println(Employee.company);
        e = null;
        System.out.println(e.company);//不会报空指针，说明静态变量跟对象无关。
    }

}

class Employee{

    private String name;

    static String company = "阿里巴巴";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


}

例2：

class StaticTest02{

    //成员变量
    int i;

    //成员方法
    //成员方法必须使用“引用.”调用
    public void m1(){
        System.out.println("m1方法");
    }

    //静态方法
    //可以使用“类名.”方式调用.也可以用“引用.”，即使用的是“引用.”，底层还是用的“类名.”
    //静态方法中不能直接访问非静态数据.
    //静态方法中不能使用this
    public static void m2(){
        //m1();错误，静态方法中不能访问非静态的方法
        //System.out.println(i);错误，静态方法中不能访问非静态的变量
        System.out.println("m2方法");
    }


    public static void main(String[] args){

        StaticTest02 st = new StaticTest02();
        st.m1();
        m2();


        st.m2();//不建议这样使用
        StaticTest02.m2();//建议这样使用            

        st = null;
        st.m2(); //不会报出空指针异常

    }

}

例3：

public class StaticTest03{

    //静态语句块
    static{
        System.out.println("静态语句块1");
    }

    static{
        System.out.println("静态语句块2");
    }

    static{
        System.out.println("静态语句块3");
    }

    //构造方法
    StaticTest03(){
        System.out.println("构造方法");
    }

    public static void main(String[] args){
        System.out.println("main main方法 1");
        System.out.println("main main方法 2");
        new StaticTest03();
        new StaticTest03();//静态语句块只执行了一次
    }
}