数组常见异常求最大最小值
/*
数组的索引编号从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岁!
- 定义一个交通工具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();//静态语句块只执行了一次
}
}