#大数据学习笔记第7天# 面向对象1

回顾


二维数组

元素本身是一维数组的数组。

三种初始化方式:
1) int[][] arr = new int[2][];
2) int[][] arr = new int[2][2];
3) int[][] arr = new int[][]{{1,2}, {3,4,5}}; // 简化写法见第4种
4) 简化写法省略掉公共的部分:int[][] arr = {{1,2}, {3,4,5}};

作业

自定义Laptop类,做好封装,并测试。
*E:\01\01 Java\day07\code\Laptop.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
自定义类
*/
class Laptop{
	//成员属性
	private String brand;
	private int price;
	
	//封装方法
	public void setBrand(String brand){
		this.brand = brand;
	}
	
	public String getBrand(){
		return brand;
	}
	
	public void setPrice(int price){
		this.price = price;
	}
	
	public int getPrice(){
		return price;
	}
		
	//构造函数
	public Laptop(){}
	public Laptop(String brand){
		this.brand = brand;
	}
	public Laptop(int price){
		this.price = price;
	}
	public Laptop(String brand, int price){
		this(brand);
		this.price = price;
	}
	
	//成员方法
	public void show(){
		System.out.println("Brand:" + brand + ", Price:" + price);
	}
}

*E:\01\01 Java\day07\code\LaptopDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
/*
测试类
*/
public class LaptopDemo{
	public static void main(String[] args){
		Laptop pc = new Laptop("Dell", 3500);
		pc.show();
	}
}

效果如图:

大纲


### 第一节课
– 面向对象编程思想
– 类的定义
– 对象的初始化
– 成员变量
– 自定义长方形类
– 自定义员工类
– 自定义计算类

### 第二节课
– static关键字
– main方法传参
– 工具类的制作
– API文档的使用
– 代码块

### 第三节课
– 继承
– 子类使用变量的原则
– super关键字
– 方法重写与子类对象实例化
– final关键字

### 第四节课
– 抽象类
– 抽象方法
– 接口


面向对象编程思想

### 1. 理解面向对象
– 面向对象是相对面向过程而言
– 面向对象和面向过程都是一种思想
– 面向对象是基于面向过程的

### 举例
– 电脑组装
– 建造汽车
– 泡咖啡
– 使用JDK的Scanner类

### 2. 面向对象的特点
– 是一种符合人们思考习惯的思想
– 可以将复杂的事情简单化
– 将程序员从执行者转换成指挥者
– 完成需求时:
– 先要去找具有所需的功能的对象来用
– 如果该对象不存在,那么创建一个具有所需功能的对象
– 简化开发并提高复用

### 3. 面向对象开发、设计、特征
– 开发的过程:其实就是不断的创建对象,使用对象,指挥对象做事情;
– 设计的过程:其实就是在管理和维护对象之间的关系;
– 面向对象的特征:
– 封装
– 继承
– 多态

### 3.2 类与对象的关系
– 使用计算机语言就是不断的在描述现实生活中的事物
– java中描述事物通过类的形式体现,类是具体事物的抽象,概念上的定义
– 对象(实例)即是该类事物实实在在的个体
– 万物皆对象

### 什么是类?
可以理解为:
– 类就是从对象中抽象出来的共性;
– 具体学生对象就是实实在在的个体;
– 一个类可以创建多个对象;

### 实例:Dog类

定义一个类主要是两方面内容:成员变量(事物的属性)、成员方法(事物的行为)。

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*
定义一个Dog类:
成员属性:事物的属性
成员方法:事物的行为
*/
public class Dog{
	// 成员属性:名字、年纪、性别
	String name="wancai";
	int age=2;
	int sex=0;
	
	// 成员方法:吃、喝、叫
	public void eat(String food){
		System.out.println("正在吃:"+food);
	}
}

类的定义

– 生活中描述事物无非就是描述事物的属性和行为。如:狗有颜色和年龄等属性,有跑和叫等行为。
– Java中用类Class来描述事物也是如此:
– 事物的属性:对应类中的成员属性
– 事物的行为:对应类中的成员方法
– 定义一个类,其实就是定义类中的成员(也就是成员属性和成员方法)

类成员的写法

– 成员变量:
– 和之前定义变量的规则是一致的
– 写在类中,成员方法的外面
– 成员方法:
– 和之前定义的方法一样
– 暂时去掉static

代码实例:

*E:\01\01 Java\day07\code\Car.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
自定义类:从具体事物到抽象概念的过程。
自定义Car类:
	- 成员变量:对应的是事物的属性
	- 成员方法:对应的是事物的行为(功能)
成员变量有默认值

类是一个抽象的概念,具体使用的是创建的实例(对象)。
如何从一个类创建出对象呢?
	创建对象 Scanner s = new Scanner(System.in)
	类型名 对象名 = new 类型名()
	
	Car car = new car();
*/

public class Car{
	String brand;
	String color;
	int age;
	
	public void run(){
		System.out.println("the car is running");
	}
	
	public void load(){
		System.out.println("the car can load people");
	}
}

*E:\01\01 Java\day07\code\CarDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*
演示Car类如何创建对象

成员变量:
	赋值
	访问
成员方法:
	访问
	
JDK里非java.lang下的包才需要手动导入。

Scanner, Math都不需要手动导入。
*/
public class CarDemo{
	public static void main(String[] args){
		Car car=new Car();
	
		//对成员属性进行赋值
		car.brand="BMW";
		car.color="White";
		car.age=2;
		
		//对成员属性进行访问
		System.out.println(car.brand);	//默认值是null
		System.out.println(car.color);	//默认值是null
		System.out.println(car.age);	//默认值是0
		
		//访问成员方法
		car.run();
		car.load();
	}
}

作业:自定义一个Laptop类。
*E:\01\01 Java\day07\code\Laptop2.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
自定义Laptop类
	成员变量:
		品牌
		尺寸
		价格
	成员方法:
		放电影
		放音乐
*/
public class Laptop2{
	//成员变量
	String brand;
	double size;
	int price;
	
	//成员方法
	public void playMovie(String name){
		System.out.println("正在播放电影:" + name);
	}
	public void playMusic(String name){
		System.out.println("正在播放音乐:" + name);
	}
}

*E:\01\01 Java\day07\code\Laptop2Demo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*
Laptop类测试
*/
public class Laptop2Demo{
	public static void main(String[] args){
		Laptop2 pc1 = new Laptop2();
		//对成员变量赋值
		pc1.brand="联想";
		pc1.size=15.6;
		pc1.price=5000;
		//成员方法调用
		System.out.println(pc1.brand);
		System.out.println(pc1.size);
		System.out.println(pc1.price);
		
		Laptop2 pc2 = new Laptop2();
		//对成员变量赋值
		pc2.brand="DELL";
		pc2.size=18.6;
		pc2.price=6000;
		//成员方法调用
		System.out.println(pc2.brand);
		System.out.println(pc2.size);
		System.out.println(pc2.price);
		
		//创建自定义类型的变量,指向已经存在的对象
		Laptop2 pc3 = pc1;
		//成员方法调用
		System.out.println(pc3.brand);
		System.out.println(pc3.size);
		System.out.println(pc3.price);
	}
}

效果如图:

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

– 成员变量
– 成员变量定义在类中,作用范围是整个类
– 实例变量随着对象的创建而存在,随着对象而消失
– 存在于对象所在的”堆内存”中
– 成员变量有默认初始化值(0,0.0,false,null)
– 局部变量
– 局部变量定义在局部范围内:方法内、形参上、代码块内
– 局部变量存在于”栈内存”中
– 方法或者语句执行完,变量空间自动释放
– 局部变量没有默认初始值,除了形参,使用之前必须赋值

### 对象内存图

形式参数的问题

Java中参数传递的原则:值传递
– 基本数据类型
– 数组
– 自定义类

举例形参是一个对象的例子:
*E:\01\01 Java\day07\code\Student.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
/*
自定义Student类
*/
public class Student{
	String name;
	int age;
	String sex;
	
	public void study(){
		System.out.println("正在学习");
	}
}

*E:\01\01 Java\day07\code\StudentTest.java*

Select Code
1
2
3
4
5
6
7
8
9
10
/*
此类用于对Student的实例进行测试
调用实例的一个方法
*/
public class StudentTest{
	public void test(Student s){
		//调用形参对象的方法
		s.study();
	}
}

*E:\01\01 Java\day07\code\StudentDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
/*
对形参是自定义类型的方法进行测试
*/
public class StudentDemo{
	public static void main(String[] args){
		//创建测试类的对象
		StudentTest st = new StudentTest();
		//创建学生对象,当成参数传给test方法
		Student s = new Student();
		//调用test方法
		st.test(s);
	}
}

效果如图:

匿名对象

匿名对象是对象的简写形式。

例子:
new StudentTest().test(new Student());

匿名对象两种使用情况:
– 对象方法仅进行一次调用时,多次调用不适合
– 匿名对象可以作为实际参数进行传递

使用匿名对象的好处:
– 简化写法,不必定义变量接住对象引用
– 对象用完之后就编程垃圾内存,可以被垃圾回收器回收(一个对象,只要有变量指向它,就不能被垃圾回收器回收)

封装

封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式,面向对象的三大特点之一,其余两个:继承和多态。

好处:
– 防止数据被任意篡改,提高安全性
– 隐藏了实现细节,仅暴露方法

如何实现封装:
– 使用private关键字修饰成员变量
– 对外提供公有的setter和getter方法

private关键字:
– 是一个权限修饰符
– 用于修饰成员(成员变量和成员方法)
– 被私有化的成员只能在本类中直接访问

常见方法:
– 将成员变量设为私有,这样就防止在类外进行访问,对外提供相应的公有的setxxx和getxxx方法
– 好处是提高对数据访问的安全性,并且可以增加复杂的逻辑控制

封装前,可以给对象的属性直接进行赋值操作,如图:

封装后,访问私有变量会直接报错,如图

代码实例:
*E:\01\01 Java\day07\code\Person.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
自定义Person类
*/
public class Person{
	//使用关键字private进行封装
	private String name;
	private int age;
	
	//定义setter方法和getter方法
	public void setName(String n){
		name = n;
	}
	public String getName(){
		return name;
	}
	
	public void setAge(int m){
		age = m;
	}
	public int getAge(){
		return age;
	}
}

*E:\01\01 Java\day07\code\PersonDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
测试Person类
*/
public class PersonDemo{
	public static void main(String[] args){
		Person p = new Person();
		//p.name="张三";
		//p.age=200;
		//System.out.println(p.name);
		//System.out.println(p.age);
		
		p.setName("李四");
		p.setAge(80);
		System.out.println(p.getName());
		System.out.println(p.getAge());
	}
}

this关键字

作用:this代表当前正在调用的方法对象。

使用场景:
– setXxx方法中对成员变量赋值,区分成员变量和局部变量
– 构造方法互相调用:this(…); 注意:构造方法中使用this或者super调用其他构造方法必须是构造方法中的第一条语句。
– 方法中调用本类其他方法

代码实例:
*E:\01\01 Java\day07\code\ThisDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
this关键字:用来区分局部变量和成员变量。使用this引用的就是成员变量。
*/
class Demo{
	private int age;
	public void setAge(int age){
		//根据究竟原则,此时的age,都是取的局部变量,没有从参数传递过来的age
		//age = age;
		this.age = age;
	}
	public int getAge(){
		return age;
	}
}

public class ThisDemo{
	public static void main(String[] args){
		Demo d = new Demo();
		d.setAge(100);
		System.out.println(d.getAge());	//0
	}
}

构造方法

特点:
– 构造方法是一种特殊的方法,它的方法名和类名相同
– 不用定义返回值类型,不用return关键字
– 其返回值可以理解为是新创建对象的引用,不用显式定义

作用:给对象初始化,即给成员变量赋值。

注意:
如果没有写,系统提供一个默认(空参)构造方法,一旦定义了构造方法就不会,系统不会提供任何构造方法
– 多个构造方法是以重载的形式存在的
– 使用new Student();实际上就是在调用空参构造方法

代码实例:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*
构造方法实例
*/
class People{
	private int age;
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	
	//定义无参构造方法
	public People(){
		System.out.println("访问了无参构造方法");
	}
	//定义有参构造方法,利用了方法重载
	public People(int age){
		System.out.println("访问了有参构造方法");
		this.age=age;
	}
	
	public void show(){
		System.out.println("当前年龄是:" + age);
	}
}

public class PeopleDemo{
	public static void main(String[] args){
		People p1 = new People();
		p1.show();
		
		People p2 = new People(10);
		p2.show();
	}
}

如图:

一个标准类的定义和使用

以Student类为例,定义标准的javabean
成员变量:自己分析,用私有修饰
成员方法:
– 空参构造方法
– 普通成员方法
– get/set方法
如果不希望单独获取成员变量的值,可以不定义setXxx方法
给成员变量赋值的方式有两种:set方法和构造方法

代码实例:
*E:\01\01 Java\day07\code\NoteBook.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/*
定义一个标准类:
	1.私有的成员属性
	2.公有的set/get方法
	3.空参构造方法
*/
public class NoteBook{
	private String brand;
	private int price;
	private double size;
	
	public void setBrand(String brand){
		this.brand=brand;
	}
	public String getBrand(){
		return brand;
	}
	public void setPrice(int price){
		this.price=price;
	}
	public int getPrice(){
		return price;
	}
	public void setSize(double size){
		this.size=size;
	}
	public double getSize(){
		return size;
	}
	
	//空参构造
	public NoteBook(){
		
	}
	//带参构造函数
	public NoteBook(String brand, int price, double size){
		this.brand=brand;
		this.price=price;
		this.size=size;
	}
	
	public void playMusic(){
		System.out.println("正在播放音乐");
	}
	
	public void show(){
		System.out.println(brand + "," + price + "," + size);
	}
}

*E:\01\01 Java\day07\code\NoteBookDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
NoteBook测试类
*/
public class NoteBookDemo{
	public static void main(String[] args){
		//访问空参构造方法
		NoteBook book1 = new NoteBook();
		book1.setBrand("Dell");
		book1.setPrice(3500);
		book1.setSize(16.8);
		book1.show();
		book1.playMusic();
		
		//访问带参构造方法
		NoteBook book2 = new NoteBook("Lenovo", 5800, 24.8);
		book2.show();
		book2.playMusic();
	}
}

效果显示:

this关键字在构造方法中的使用:

– 在某个构造方法中调用本类的其他构造方法
– 必须放在构造方法的第一句

代码实例:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
public NoteBook(String brand, int price, double size){
	this(brand, price);
	this.size=size;
}

//this关键字的使用
public NoteBook(String brand, int price){
	this(price);
	this.brand=brand;
}
public NoteBook(int price){
	this.price=price;
}

一个对象的完整实例化过程

以Student s=new Student();为例

– 加载Student.class文件到方法区;
– 在栈内存中定义变量s;
– 在堆内存中开辟空间;
– 对成员变量进行默认初始化(0,0.0,false,null)
– 对成员变量进行显式初始化(定义成员变量时赋值)
– 调用构造方法(成员变量赋值)
– 成员变量初始化完毕,将对象地址值返回给栈中的变量s

### 练习
什么时候将变量定义为成员变量?
变量是用来描述类的,如果变量是这个类的描述信息,就定义为成员变量,否则,应该定义为方法形参或者方法体内,即:局部变量。

变量定义的原则:范围越小越好,能够被及时回收。

练习题:
1. 定义长方形类,其中包含求周长(perimeter)和面积(area)的方法。注意:由于没有必要单独获取长和宽,所以不需要定义get方法。
2. 定义员工类,自己分析有什么成员变量,包含一个显示所有成员变量的方法,然后测试。
3. 自定义计算类,提供基本的加减乘除运算,并测试。被计算的数和类之间没有从属关系,最好不要定义成员变量,而是方法的参数。

例1:

*E:\01\01 Java\day07\code\Rectangle.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
自定义长方形类
*/
public class Rectangle{
	private int length;
	private int width;
	
	public void setLength(int length){
		this.length=length;
	}
	public void setWidth(int width){
		this.width=width;
	}
	
	public int getPerimeter(){
		return 2*(length+width);
	}
	public int getArea(){
		return length * width;
	}
}

*E:\01\01 Java\day07\code\RectangleDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
测试长方形类
*/
import java.util.Scanner;

public class RectangleDemo{
	public static void main(String[] args){
		Rectangle r = new Rectangle();
		Scanner s = new Scanner(System.in);
		
		System.out.println("请输入长方形的长度:");
		r.setLength(s.nextInt());
		System.out.println("请输入长方形的宽度:");
		r.setWidth(s.nextInt());
		
		System.out.println("周长:"+r.getPerimeter());
		System.out.println("面积:"+r.getArea());
		
	}
}

例2:

*E:\01\01 Java\day07\code\Employee.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/*
自定义员工类
*/
public class Employee{
	private String name;
	private String dept;
	private int age;
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setDept(String dept){
		this.dept = dept;
	}
	public String getDept(){
		return dept;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	
	public Employee(){}
	public Employee(String name, String dept, int age){
		this.name=name;
		this.dept=dept;
		this.age=age;
	}
	
	public void show(){
		System.out.println(name + ", " + dept + ", " + age);
	}
}

*E:\01\01 Java\day07\code\EmployeeDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
/*
测试员工类
*/
public class EmployeeDemo{
	public static void main(String[] args){
		Employee e = new Employee("Leon", "IT", 31);
		e.show();
	}
}

例3:

*E:\01\01 Java\day07\code\Calc.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
自定义两个数用于加减乘除
*/
public class Calc{
	private int num1;
	private int num2;
	
	public Calc(){}
	
	public int add(int num1, int num2){
		return num1+num2;
	}
	public int sub(int num1, int num2){
		return num1-num2;
	}
	public int mul(int num1, int num2){
		return num1*num2;
	}
	public double div(int num1, int num2){
		return num1/num2;
	}
}

*E:\01\01 Java\day07\code\CalcDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
用于计算类的测试用例
*/
import java.util.Scanner;

public class CalcDemo{
	public static void main(String[] args){
		Calc c = new Calc();
		Scanner s=new Scanner(System.in);
		int num1;
		int num2;
		
		System.out.println("请输入第1个数:");
		num1 = s.nextInt();
		System.out.println("请输入第2个数:");
		num2 = s.nextInt();
		
		System.out.println("加:" + c.add(num1, num2));
		System.out.println("减:" + c.sub(num1, num2));
		System.out.println("乘:" + c.mul(num1, num2));
		System.out.println("除:" + c.div(num1, num2));
	}
}

## static关键字
用于修饰成员(成员变量和成员方法),称为类成员。

代码实例:

*E:\01\01 Java\day07\code\StaticTest.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
/*
演示static关键字
*/
public class StaticTest{
	//修饰类成员属性
	static int age;
	
	//修饰类成员方法
	public static void show(){
		System.out.println("Hello");
	}
}

*E:\01\01 Java\day07\code\StaticDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
测试Staic修饰关键字的使用
*/
public class StaticDemo{
	public static void main(String[] args){
		//使用类名直接访问类成员
		StaticTest.age=10;
		System.out.println(StaticTest.age);
		StaticTest.show();
		
		//使用对象来访问类成员
		StaticTest st = new StaticTest();
		st.age=20;
		System.out.println(st.age);
		st.show();
	}
}

总结:静态方法不能访问非静态成员;非静态方法则可以访问静态成员。(原因是先有静态成员)

被修饰后的类成员有如下特点:
– 随着类的加载而加载
– 优先于对象而存在
– 被这个类的所有对象共享
– 可以直接被类名调用,也可以使用对象调用,但推荐使用类名调用,因为static修饰的成员就是类成员

使用时注意:
– 静态方法只能访问静态成员(变量,方法)
– 静态方法中不可以使用this, super关键字
– 非静态方法可以访问静态成员

### 演示Staic关键字的例子

*E:\01\01 Java\day07\code\StaticTest2.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
/*
演示Static关键字
*/
public class StaticTest2{
	static String country="China";
	String name;
	
	public void show(){
		System.out.println(country + " - " + name);
	}
}

*E:\01\01 Java\day07\code\StaticTest2Demo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
演示StaticTest2类
*/
public class StaticTest2Demo{
	public static void main(String[] args){
		StaticTest2 st1 = new StaticTest2();
		st1.name="Leon";
		st1.show();
		
		StaticTest2 st2 = new StaticTest2();
		st2.name="Tom";
		st2.country="USA";
		st2.show();
	}
}

### 静态变量和实例变量之间的区别
– 所属不同
– 静态变量属于类,也称为类变量
– 实例变量属于对象,也称为对象(实例)变量
– 在内存中的位置不同
– 静态变量在方法区中
– 实例变量在堆内存
– 生命周期不同
– 静态变量随着类的加载而加载,随着类的消失而消失
– 实例变量随着对象的创建而存在,随着对象的消失而消失
– 调用方法不同
– 静态变量可以通过类名和对象名两种方式调用,推荐使用类名调用
– 实例变量只能使用对象名的方式调用

## main方法传参与格式说明
public static void main(String[] args){…}

– public: 修饰符,用来控制访问权限的。
– static: 修饰main方法属于类方法,通过类名直接调用,JVM不用创建对象即可直接调用。
– void: 返回值为空,main方法不用返回任何值。
– main: 默认的程序入口,不是关键字,JVM从这里开始执行。
– String[] args: 形参列表,String类型的数组。
– args: 形参名,也就数数组名。

如何使用?早期可以从键盘输入,但后面JDK1.5以后则被Scanner取代。如图所示:

代码实例:
*E:\01\01 Java\day07\code\Args.java*

Select Code
1
2
3
4
5
6
7
8
9
10
/*
	试验main方法的参数传递
	*/
	public class Args{
		public static void main(String[] args){
			for(int i=0; i<args.length; i++){
				System.out.println(args[i]);
			}
		}
	}

## 工具类的制作
1. 写一个类,包含一个方法用来遍历一维数组。
2. 使用static修饰,可以直接使用类名来调用,方法在main中调用。
3. 将这个类单独放到一个文件中,形成工具类。
4. 可以继续定义更多的关于数组的操作,获得最值等,丰富工具类。

注意:
– 编译的时候,只编译测试类即可
– 通过类名和对象名的方式都能调用,如果不想让使用对象名的方式调用的话,将构造方法私有化即可

### 制作一个工具类实例

代码实例:
*E:\01\01 Java\day07\code\ArrayTool.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*
	求一个求数组的最值工具类
	@author webjust
	@version 1.0
	*/
	public class ArrayTool{
		/**
		* 求最大值
		* @param arr 需要查找最大值的数组
		* @return 返回数组的最大值
		*/
		public static int getMax(int[] arr){
			int max = arr[0];
			for(int i=1; i<arr.length; i++){
				if(arr[i] > max){
					max=arr[i];
				}
			}
			return max;
		}
		
		/**
		* 求最小值
		* @param arr 需要查找最小值的数组
		* @return 返回数组的最小值
		*/
		public static int getMin(int[] arr){
			int min = arr[0];
			for(int i=1; i<arr.length; i++){
				if(arr[i] < min){
					min=arr[i];
				}
			}
			return min;
		}
	}

*E:\01\01 Java\day07\code\ArrayToolTest.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
/*
	测试工具类
	*/
	public class ArrayToolTest{
		public static void main(String[] args){
			int[] arr = {1,2,4,7,9,10};
			int max = ArrayTool.getMax(arr);
			int min = ArrayTool.getMin(arr);
			System.out.println(max + " - " + min);
		}
	}

### 工具类说明书的制作
– 写一个完整的工具类,需要使用public修饰
– 类名上加@author, @version标签
– 方法上加@param, @return标签
– 注意:方法上标签中不用加类型
– 最终使用命令生成文档:`javadoc -d mydoc -version -author ArrayTool.java`

生成的doc文档如图:

## API文档

– 在线版
– 离线版
– 关注事项
– 所在包
– 构造方法
– 形参,返回值类型
– 是否是static静态的
– 从哪个版本开始的

代码实例:
*E:\01\01 Java\day07\code\MathDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
/*
API文档的使用:Math类
*/
public class MathDemo{
	public static void main(String[] args){
		System.out.println(Math.max(1, 8));	//8
		System.out.println(Math.min(-1, 2));//-1
	}
}

## 代码块
局部代码块:
在方法内部,用于限定变量的生命周期,及时释放内存。

构造代码块:
定义在成员位置,用于抽取不同构造方法中相同的部分。构造方法调用一次,构造代码块就执行一次。

静态代码块:
static修饰的构造代码块,用于对类进行初始化。静态代码块随着类的加载而执行,整个过程中只执行一次。

代码演示实例:
*E:\01\01 Java\day07\code\BlockDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/*
代码块测试类
*/
class BlockTest{
	static int num;
	
	//构造代码块:在任何一个构造方法前都执行一次
	{
		System.out.println("欢迎来到:");
	}
	
	//静态代码块:对类进行初始化,在类开始加载时就执行,整个过程只执行一次
	static {
		System.out.println("静态代码块1");
	}
	static {
		System.out.println("静态代码块2");
	}
	
	public BlockTest(){
		System.out.println("欢迎来到1:");
		System.out.println("无参构造方法");
	}
	public BlockTest(int num){
		System.out.println("欢迎来到2:");
		System.out.println("带参构造方法");
	}
	
	//局部代码块演示
	public void show(){
		{
			int a=10;
		}
		{
			int a=20;
		}
	}
}

public class BlockDemo{
	public static void main(String[] args){
		BlockTest bt1=new BlockTest();
		BlockTest bt2=new BlockTest(1);
	}
}

面试题:静态代码块,构造代码块,构造方法的执行顺序和特点?
答:静态代码块 -> 构造代码块 -> 构造方法。

## 继承 extends
– 多个类中存在多个相同的属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只需从抽取出来的那那个类扩展(extends)即可
– 需要扩展的类称为子类,抽取出来的那个类称为父类,或者超类,或者基类
– 通过关键字 extends 让类与类之间产生继承关系

class 子类名 extends 父类{/*类体*/}

继承的出现,提高了代码的可复用性。

继承的出现让类和类之间开始产生了关系,提供了多态的前提。

代码实例:

*E:\01\01 Java\day07\code\Stu.java*

Select Code
1
2
3
4
5
6
/*
继承:继承人类
*/
class Stu extends Human{
	
}

*E:\01\01 Java\day07\code\Human.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
/*
继承:基类
*/
class Human{
	public void eat(){
		System.out.println("eat....");
	}
	public void sleep(){
		System.out.println("sleep....");
	}
}

*E:\01\01 Java\day07\code\Teacher.java*

Select Code
1
2
3
4
5
6
/*
继承:继承人类
*/
class Teacher extends Human{

}

*E:\01\01 Java\day07\code\HumanDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
继承的测试
*/
public class HumanDemo{
	public static void main(String[] args){
		Stu s = new Stu();
		s.eat();
		s.sleep();
		
		Teacher t = new Teacher();
		t.eat();
		t.sleep();
	}
}

### 继承的特点
– Java只支持单继承,不支持多继承。一个类只能有一个父类,不能由多个父类。
– Java支持多层继承
– 定义继承需要注意,不仅要为了获得其他类的某个功能才去继承。类与类之间,需要有所属关系,即子类是父类的一种。
– 私有成员不能被继承
– 继承关系中成员变量的关系:子类中方法使用变量的“就近原则”
– 1. 现在子类方法中查找
– 2. 再在子类的成员变量中查找
– 3. 再找父类的成员变量

实例1:

*E:\01\01 Java\day07\code\ExtendDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
测试一个类只能继承一个父类
*/
class A{
	
}
class B{
	
}
class C extends A,B{
	
}

public class ExtendDemo{
	public static void main(String[] args){
		
	}
}

实例2:

*E:\01\01 Java\day07\code\ExtendDemo2.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
继承特点:不能继承私有成员
*/
class A{
	private int num = 1; //num 在 A 中是 private 访问控制
	//int num = 1;
}

class B extends A{
	public void show(){
		System.out.println(num);
	}
}

public class ExtendDemo2{
	public static void main(String[] args){
		B b1 = new B();
		b1.show();
	}
}

实例3:

*E:\01\01 Java\day07\code*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
继承特性:就近原则
方法内 > 本类中 > 继承属性
*/
class A{
	int num = 1;
}

class B extends A{
	int num = 2;
	public void show(){
		int num = 3;
		System.out.println(num);
	}
}

public class ExtendDemo3{
	public static void main(String[] args){
		B b1 = new B();
		b1.show();	//3
	}
}

## super 关键字
– super和this的用法类似
– this代表本类对象的引用
– super代表父类对象的内存空间的标识

### super的使用场景
子父类出现同名成员时,用super进行区分:
– super.成员属性
– super.成员方法()
子类使用super调用父类的构造方法
– super(…)

实例:

*E:\01\01 Java\day07\code\SuperDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
super关键字
*/
class A{
	int num=10;
}
class B extends A{
	int num=20;
	public void show(){
		System.out.println(num);	//20
		System.out.println(super.num);	//10
	}
}

public class SuperDemo{
	public static void main(String[] args){
		B b1 = new B();
		b1.show();
	}
}

代码实例:

*E:\01\01 Java\day07\code\SuperDemo2.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*
Super关键字特性
*/
class A{
	int num=10;
	public A(){
		System.out.println("父类无参构造方法");
	}
	public A(String s){
		System.out.println(s);
		System.out.println("父类带参构造方法");
	}
}
class B extends A{
	int num=20;
	//程序会默认先执行B类的无参构造方法,然后执行父类的无参构造方法
	public B(){
		//必须在程序的第一行,显示的调用父类的带参的构造方法,使用Super关键字表示是父类
		super("1000"); //不放在第一行,会报错
		System.out.println("子类无参构造方法重写...");
	}
	public void show(){
		System.out.println(num);	//20
		System.out.println(super.num);	//10
	}
}

public class SuperDemo2{
	public static void main(String[] args){
		B b1 = new B();
		b1.show();
	}
}

## 方法重写 Override|Overwrite
– 子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为重写或者复写
– 父类中的私有方法不可以被重写
– 在子类重写方法中,继续使用被重写的方法可以使用super.方法名(…)
– 覆盖注意事项:覆盖时,子类方法权限一定要大于等于父类的方法权限;除了访问权限外,其他部分和父类保持一致;静态只能覆盖静态;
– 覆盖的应用:当子类需要父类的功能,而功能主体子类有自己的特有内容时,可以复写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容

代码实例:

*E:\01\01 Java\day07\code\OverrideDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
方法重写实例
*/
class Father{
	public void test(){
		System.out.println("Father test()...");
	}
	public static void test2(){
		System.out.println("Father test2()...");
	}
	void test3(){
		System.out.println("Father test3()...");
	}
}

class Son extends Father{
	//重写父类方法,需要同名方法
	public void test(){
		super.test();	//在子类中调用父类的方法
		System.out.println("Son test()...");
	}
	//重写静态方法,子类必须也是静态方法
	public static void test2(){
		System.out.println("Son test2()...");
	}
	//子类的权限范围必须大于父类的方法
	public void test3(){
		System.out.println("Son test3()...");
	}
}

public class OverrideDemo{
	public static void main(String[] args){
		Son s = new Son();
		s.test();
		s.test2();
		s.test3();
	}
}

### 子类的实例化过程
– 子类中所有的构造方法默认都会访问父类中的空参构造方法,因为每一个构造方法的第一行都有一条默认的语句super(),除非第一行是用this或super显示调用了其他的构造方法
– 子类会具备父类中的数据,所以要先明确父类是如何对这些数据初始化的,也就是父类对象必需在子类对象初始化前初始化ok
– 当父类中没有空参构造方法时,子类的构造方法必须通过this或super语句指定要访问的构造方法

代码实例:

*E:\01\01 Java\day07\code\OverrideDemo2.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
方法重写实例
*/
class Father{
	public Father(){
		System.out.println("Father构造方法");
	}
}

class Son extends Father{
	public Son(){
		super();	//默认会添加父类的无参构造方法,也可以指定为其他的父类构造方法
		System.out.println("Son构造方法");
	}
}

public class OverrideDemo2{
	public static void main(String[] args){
		Son s = new Son();
	}
}

## final 关键字
final可以修饰类、方法、变量。
图oop-10.jpg

final修饰的成员变量,必须在构造方法执行完成之前初始化:
1. 可以在定义的时候就赋值(最常见)
2. 可以在构造代码块中赋值,多个构造代码块中不能重复赋值

代码实例:

*E:\01\01 Java\day07\code\FinalDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
final关键字
*/
class A{
	public final int num;
}
class B extends A{
	int num=20;
	public void show(){
		System.out.println(num);
	}
}

public class FinalDemo{
	public static void main(String[] args){
		B b1=new B();
		b1.show();
	}
}

## 抽象类
### 1. 抽象类概述
抽象定义:抽象就是从多个事物中将共性的,本质的内容抽取出来
抽象类定义:Java中可以定义没有方法体的方法,该方法的具体实现由子类来完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。
抽象方法的由来:多个对象都具备相同的功能,但是功能的具体实现有所不同,那么在抽取过程中,只抽取了功能定义,并未抽取功能主体,那么只有功能声明,没有功能主体的方法称为抽象方法。

> 如果在父类中定义了一个各子类都有不同实现的方法,那么子类需要重写这个方法,为什么父类还要定义这个方法?这是为多态做准备。

由于多态的要求:父类引用指向子类实例,但父类不能调用子类独有的方法,为了使用多态,父类中必须定义这个方法,但是方法的实现又会被子类重写。
为了既能使用多态,又能省去在父类中的麻烦,Java提供了抽象方法,在父类中只定义方法名,不实现方法体。

图oop-10.jpg

### 2. 抽象类特点
抽象类和抽象方法必须用abstract关键字来修饰。
抽象方法只有方法声明,没有方法体,定义在抽象类中。
抽象类不可以被实例化,原因如下:
– 抽象类是具体事物抽象出来的,本身不是具体的,没有对应的实例。
– 假设抽象类可以创建对象,那么调用其抽象方法,将无意义。
抽象类通过其子类实例化,而子类需要实现抽象类中所有的抽象方法后才能创建对象,否则该子类也是抽象类。

修饰符 abstract 返回值类型 方法名(参数列表);

### 3. 抽象类举例代码
子类Dog, Cat分别实现Animal类的抽象方法eat()。

2个代码实例

### 4. 抽象类相关问题
– 抽象类是否可以有构造方法?
抽象类中可以有成员变量,而构造方法的作用就是对成员变量初始化的,所以可以有构造方法。

– 抽象关键字abstract不可以和哪些关键字共存?
static, final, private

– 抽象类中可不可以没有抽象方法?
可以,比如可以不让外界实例化。

## 接口
类可以继承一个类的同时实现多个接口

class Dog extends Animal implements CanJump,CanWin{

}

接口与接口之间是继承关系

public interface InterfaceA{void m1();}
public interface InterfaceB{void m2();}
public interface InterfaceC extends InterfaceA,InterfaceB{
//有两个抽象方法继承至父类接口;
}

接口是抽象的一种机制。

现实事物的共性抽取成类:
将不同类中的同名方法抽象成抽象方法,形成抽象类。
对类的成员变量和方法继续抽象的话,就形成接口,接口是类的最高级别的抽象机制。

接口中只有常量和抽象方法
接口是一种规范,实现一个接口,就需要实现其中所有的抽象方法。

格式:

Select Code
1
2
3
4
[public] interface 接口名 [extends 父接口1,父接口2...]{
	//成员常量: public static final
	//抽象方法: public abstract
}

– public: 可以在所有包中访问,不加的话,表明只能在本包中访问该接口
– 接口中的成员修饰符是固定的,写与不写都有
– 成员常量: public static final
– 抽象方法: public abstract
– 接口中的成员都是public修饰的。
– 接口的出现将”多继承”通过另外一种形式体现出来,即”多实现”。

### 接口的特点
接口是程序的扩展功能:想给类A增加一个功能,只需要定义一个接口,然后自定义一个类,继承自类A,并实现这个接口,即可完成把类A的功能扩展。


*E:\01\01 Java\day07\code\InterfaceDemo.java*

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
接口:对功能的扩展
*/
class Dog{
	public void eat(){
		System.out.println("Dog eat()....");
	}
}

interface Jump{
	public abstract void jump();
}

class JumpDog extends Dog implements Jump{
	public void jump(){
		System.out.println("Dog jump()....");
	}
}

public class InterfaceDemo {
	public static void main(String[] args){
		JumpDog jd = new JumpDog();
		jd.eat();
		jd.jump();
	}
}

– 接口的出现降低耦合性
接口只定义规范,不关心实现,这是设计和实现相分离的表现。

– 接口可以用来多实现

Select Code
1
2
3
class SuperMan implements CanFly,CanSwin,CanFight{
	//实现在所有接口中定义的抽象方法
}

#大数据学习笔记# 汇总

Java


Linux


Hadoop


Zookeeper


Hive


#大数据学习笔记第6天# 数组

回顾

方法的重载:为了方法名的重用。遵守两同、一不同原则(同类同方法名,不同的参数个数或参数类型)。

大纲

### 第一节课
– 知识点回顾
– 数组概述
– 数组模拟打分实例

### 第二节课
– 方法调用的值传递原理

### 第三节课
– 二维数组
– 二维数组的遍历
– 二维数组计数求和

### 第四节课
– 二维数组练习
– 二维数组打印杨辉三角

数组基础

概念:同一种类型数据的集合,可以是基本的数据类型,也可以是引用数据类型。

### 特点
1. 数组存储的都是相同数据类型的元素。
2. 数组的长度也就是数组中元素的个数。
3. 元素从0开始编号,编号也称为索引\index\下标。
4. 数组中元素的访问方式是通过数组名+索引的方式。

### 数组的定义格式
基本数据类型变量的定义:int x;
数组类型变量的定义:int[] arr;

### 数组的初始化
初始化方式1:

动态初始化:数组的创建和元素的赋值分开进行;
格式:元素类型[] 数组名=new 元素类型[数组长度];

int[] arr = new int[3];

初始化方式2:

静态初始化:数组创建时就给数组元素赋值;
格式:元素类型[] 数组名=new 元素类型[]{元素1,元素2,…};

int[] arr = new int[]{1,2,3}
静态初始化的简写方式:int[] arr = {1,2,3}

直接打印数组类型的变量,会发现结果是一段看不懂的字符串,这就是引用数据类型变量的特点;它实际上代表的是一段内存空间的十六进制表示形式,真正的数据在JVM的堆内存空间中。

### 代码实例

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
public class ArrayDemo{
public static void main(String[] args){
	// 动态初始化
	int[] arr1 = new int[3];
	System.out.println(arr1);	//打印的是包含了十六进制的字符串,实际上代表的是数组的地址
	
	// 静态初始化
	int[] arr2 = new int[]{1,2,3};
	int[] arr3 = {4,5,6};
	System.out.println(arr2);
	System.out.println(arr3);
}
}

内存结构

Java程序在运行时,为了提高运行效率,对内存进行了不同区域的划分,每一种区域都有特定的处理数据的方式和内存管理方式。

如图:

– 栈内存:用于存储局部变量,当数据使用完,所占空间会自动释放;
– 堆内存:存放数组和对象,通过new建立的实例都存放在堆内存中;
– 每一个实例都有内存地址值;
– 实例中的变量都有默认初始值;
– 当实例不再被使用,会在不确定的时间被垃圾回收器回收;
– 方法区:存放类文件和方法(面向对象部分再阐述)

本地方法栈:供本地方法使用,与操作系统有关。
程序计数器:对字节码文件计数;

常见异常

1. 数组索引越界异常
2. 空指针异常

### 代码实例

Select Code
1
2
3
4
5
6
7
8
9
public class ArrayDemo2{
public static void main(String[] args){
	int[] arr = new int[2];
	// arr[2] = 1;	//java.lang.ArrayIndexOutOfBoundsException
	
	arr=null;
	System.out.print(arr[0]); //java.lang.NullPointerException
}
}

案例:数组模拟打分

从键盘录入5个分数作为评分,然后去除一个最高分,去除一个最低分,用剩余的数据的平均分作为最终的评分;

代码:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.util.Scanner;

public class Demo01{
public static void main(String[] args){
	Scanner s = new Scanner(System.in);
	int[] score = new int[5];
	System.out.println("请输入第1个评分");
	score[0] = s.nextInt();
	System.out.println("请输入第2个评分");
	score[1] = s.nextInt();
	System.out.println("请输入第3个评分");
	score[2] = s.nextInt();
	System.out.println("请输入第4个评分");
	score[3] = s.nextInt();
	System.out.println("请输入第5个评分");
	score[4] = s.nextInt();
	
	double res = getScore(score);
	System.out.println("最终的评分是:" + res);
}

public static int getMax(int[] arr){
	int max = arr[0];
	for(int i=0; i < arr.length; i++){
		if(arr[i] > max){
			max = arr[i];
		}
	}
	return max;
}

public static int getMin(int[] arr){
	int min = arr[0];
	for(int i=0; i < arr.length; i++){
		if(arr[i] < min){
			min = arr[i];
		}
	}
	return min;
}

public static double getScore(int[] arr){
	int max = getMax(arr);
	int min = getMin(arr);
	int sum = 0;
	for(int i=0; i<arr.length; i++){
		sum += arr[i];
	}
	double score = (sum - max - min) / (arr.length - 2.0);
	return score;
}
}

方法调用的值传递原理

Java中参数传递(实参->形参)的问题:

– 参数是基本数据类型,传递的是数值的副本;
– 参数是引用数据类型,传递的是引用的副本;

### 代码实例

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 参数是基本数据类型,传递的是数值的副本;
public class Demo02{
	public static void main(String[] args){
		int x=10;
		int y=20;
		change(x, y);
		System.out.println("x=" + x + ", y=" + y);
	}
	
	public static void change(int x, int y){
		System.out.println("方法内部x=" + x + ", y=" + y);
		x = 0;
		y = 0;
		System.out.println("方法内部x=" + x + ", y=" + y);
	}
}

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//参数是引用数据类型,传递的是引用的副本;
public class Demo03{
	public static void main(String[] args){
		int[] arr = {1,2,3};
		change(arr);
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i]+" ");
		}
	}
	
	public static void change(int[] arr){
		for(int i=0; i<arr.length; i++){
			arr[i]=0;
		}
		System.out.print("方法内部数组元素是:");
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
}

杨辉三角


– 端点的数为1.
– 每个数等于它上方两数之和。
– 每行数字左右对称,由1开始逐渐变大。
– 第n行的数字有n项。
– 第n行数字和为2^(n-1)。
– 每个数字等于上一行的左右两个数字之和。可用此性质写出整个杨辉三角。即第n+1行的第i个数等于第n行的第i-1个数和第i个数之和,这也是组合数的性质之一。

代码实现:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/*
	定义一个杨辉三角,10行
*/

public class YangHuiTrianger{
	public static void main(String[] args){
		int[][] arr = new int[10][];
		
		for(int i=0; i < arr.length; i++){
			int[] line = new int[i+1];
			arr[i] = line;
			
			//遍历一维数组
			for(int j=0; j<arr[i].length; j++){
				if(i==0){
					arr[i][j] = 1;
				}
				if(j==0 || j==(arr[i].length-1)){
					arr[i][j] = 1;
				}else{
					arr[i][j]=arr[i-1][j-1] + arr[i-1][j];
				}
			}
		}
		
		printArray(arr);
	}
	
	// 打印二维数组
	public static void printArray(int[][] arr){
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}

展示效果:

#大数据学习笔记第5天# 函数

## 回顾

## 大纲
– 方法的定义
– 方法的特点
– 方法的应用
– 方法的重载

## 方法的定义
什么是方法?

– 方法就是定义在类中的,具有特定功能的一段小程序;
– 方法也称为函数;
– 方法可以接收输入,根据需要输出内容;

方法定义的格式:

Select Code
1
2
3
4
修饰符 返回值类型 方法名(参数类型 形参1, 参数类型 形参2, ...){
	方法体语句;
	return [返回值];
}
  • 修饰符:暂时固定写成public static
  • 返回值类型:方法执行后返回结果的数据类型
  • 形式参数列表:
    • 参数类型:是形式参数的数据类型;
    • 形式参数:是一个变量,用于接收方法被调用时传给方法的实际参数的值
    • 实际参数:放大调用时传递给形式参数的具体数值
  • return:关键字,用于表示方法结束
  • 返回值:该方法运算后需要返回给调用者的结果,其类型要和返回值类型匹配,或者可以自动转型

## 方法的特点:
– 定义方法可以将功能代码进行封装;
– 提高了代码的复用性;
– 方法只有被调用才会被执行;
– 注意:方法之间是调用关系,不可以在方法内部再定义方法;

## 方法练习:
1. 定义方法,用于计算两个double整型的和;
2. 定义方法,用于打印九九乘法表;
3. 定义方法,用于打印任何行数和列数的“+”号;
4. 定义方法,用于判断一个int数是否是偶数;
5. 定义方法,接收一个int值,返回该值对应的应该是星期几,要求switch结构实现;
6. 定义方法,获取两个数中的最大值;
7. 定义方法,获取三个数中的最大值;

### 答案
题1:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
/*
	定义方法,用于计算两个double整型的和;
*/
public class Demo01{
	public static void main(String[] args){
		System.out.println(add(1.0,2.0));	//3.0
	}
	
	public static double add(double d1, double d2){
		return d1+d2;
	}
}

题2:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
	定义方法,用于打印九九乘法表;
*/
public class Demo02{
	public static void main(String[] args){
		chenfabiao();
	}
	
	public static void chenfabiao(){
		for(int i=1; i<=9; i++){
			for(int j=1; j<=i; j++){
				System.out.print(i+"*"+j+"="+(i * j)+"\t");
			}
			System.out.println();
		}
	}
}

打印效果如图:

题3:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;
/*
	定义方法,用于打印任何行数和列数的“+”号;
*/
public class Demo03{
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		System.out.println("请输入行数:");
		int line = s.nextInt();
		System.out.println("请输入列数:");
		int col = s.nextInt();
		print_plus(line,col);
	}
	
	public static void print_plus(int line, int col){
		for(int i=1; i<=line; i++){
			for(int j=1; j<=col; j++){
				System.out.print("+");
			}
			System.out.println();
		}
	}
}

打印效果如图:

题4:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Scanner;
/*
	定义方法,用于判断一个int数是否是偶数;
*/
public class Demo04{
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		System.out.println("请输入一个int整数:");
		int num = s.nextInt();
		if(is_even(num)){
			System.out.println("这是一个偶数");
		}else{
			System.out.println("这是一个奇数");
		}
	}
	
	public static boolean is_even(int num){
		if(num % 2 == 0){
			return true;
		} else {
			return false;
		}
	}
}

打印效果如图:

题5:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.Scanner;
/*
	定义方法,接收一个int值,返回该值对应的应该是星期几,要求switch结构实现;
*/
public class Demo05{
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		System.out.println("请输入一个1-7范围内的整数:");
		int num = s.nextInt();
		System.out.print("这表示:" + week_day(num));
	}
	
	public static String week_day(int num){
		String s="";
		switch(num){
			case 1:
				s = "星期一";
				break;
			case 2:
				s = "星期二";
				break;
			case 3:
				s = "星期三";
				break;
			case 4:
				s = "星期四";
				break;
			case 5:
				s = "星期五";
				break;
			case 6:
				s = "星期六";
				break;
			case 7:
				s = "星期日";
				break;
			default:
				s = "非法值";
		}
		return s;
	}
}

打印效果如图:

题6:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner;
/*
	定义方法,获取两个数中的最大值;
*/
public class Demo06{
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		System.out.println("请输入第一个整数:");
		int num1 = s.nextInt();
		System.out.println("请输入第二个整数:");
		int num2 = s.nextInt();
		System.out.println("比较大的整数是:" + max(num1, num2));
	}
	
	public static int max(int num1, int num2){
		if(num1 >= num2){
			return num1;
		}else{
			return num2;
		}
	}
}

打印效果如图:

题7:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.Scanner;
/*
	定义方法,获取三个数中的最大值;
*/
public class Demo07{
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		System.out.println("请输入第一个小数:");
		Double num1 = s.nextDouble();
		System.out.println("请输入第二个小数:");
		Double num2 = s.nextDouble();
		System.out.println("请输入第三个小数:");
		Double num3 = s.nextDouble();
		System.out.println("三个数中最大的整数是:" + max(num1, num2, num3));
	}
	
	public static double max(double d1, double d2, double d3){
		if(d1 > d2){
			if(d1 > d3){
				return d1;
			}else{
				return d3;
			}
		}else{
			if(d2 > d3){
				return d2;
			}else{
				return d3;
			}
		}
	}
}

打印效果如图:

## 方法的重载
在同一个类中,允许出现同名,但是形参列表不同的多个方法,称为方法的重载

为什么有方法的重载?
为了重复使用方法名,简化编程,方便阅读。

程序如何辨别到底调用的是哪个方法?
重载方法虽然方法名相同,但是参数列表不同,虚拟机就是根据调用方法时,传递不同的参数来决定到底调用的是哪一个方法。

## 重载示例与练习

#大数据学习笔记第4天# 流程控制

## 回顾

## 作用

## 大纲
– Switch结构
– 循环结构
– for循环
– while循环
– do…while循环
– 循环嵌套
– 2个案例:猜数字、循环输入成绩进行判断

## 第一节课 ##
– 回顾、作业
– Switch结构
– Switch练习

## 第二节课 ##
– for循环
– for循环练习

## 第三节课 ##
– while循环
– do…while循环
– 循环嵌套

## 第四节课 ##
– 案例:循环嵌套之九九乘法表
– 案例:猜数字
– 案例:循环输入成绩进行判断

## 分支结构:switch

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
switch(表达式或变量){
	case 取值1:
		语句体1;
		break;
	case 取值2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}

### switch注意事项:

  • switch语句表达式的类型有:byte,short,int,char,String(1.7之后才支持)和枚举类型;
  • case之间与default没有顺序,case相当于入口点,没有匹配的case将执行default,default也不是必须的;
  • 结束switch语句的情况:遇到break或执行到switch语句结束;
  • 如果匹配的case或者default没有对应的break,那么程序会继续向下执行,运行可以执行的语句,直到遇到break或者switch结尾;

## 循环结构:概述
循环语句可以在满足循环条件的情况下,反复执行某一段代码;被反复执行的代码称为循环体;需要在适当的时候,把循环条件改为假,从而结束循环,否则循环将一直执行下去,形成死循环;

完整的循环应该包含以下四个部分:

  • 初始化语句:初始化工作,在循环体开始之前执行;
  • 循环条件:一个boolean表达式,决定是否执行循环体;
  • 循环体:反复执行的部分;
  • 迭代语句:在循环体执行完之后执行,然后再去判断循环条件,一般用来控制循环条件中的变量,使循环在合适的时候结束;

## 循环结构:for
格式:

Select Code
1
2
3
for(初始化表达式;条件表达式;循环变量控制语句){
循环体语句;
}

格式说明:for运行的顺序

1. 执行初始化表达式,只执行一次,通常是定义循环变量语句;
2. 判断循环条件,为真就往下执行,为假就结束循环;
3. 执行循环体语句;
4. 执行循环变量控制语句,一般是循环变量的自增或自减;
5. 回到第2步,重复这个过程,直到为假时结束;

## 10个练习题
1. 在控制台上依次打印1-10;
2. 在控制台上依次打印10-1;
3. 求1-10所有数之和;
4. 求出1-100之间的所有偶数之和;
5. 求出1-100之间的所有奇数之和;
6. 求出5的阶乘;
7. 求水仙花数;
8. 列出5位数中的回文数;
9. 统计1000以内,同时是3,5,7的倍数的数有多少个?
10. 在1-100之间,若是3的倍数,则在它之后输出中文“三”,若是5的倍数,则在它之后输出中文“五”,若是7的倍数,则在它之后输出中文“七”

答案:

01题:

Select Code
1
2
3
4
5
6
7
public class Demo01{
	public static void main(String[] args){
		for(int i=1;i<=10;i++){
			System.out.println(i);
		}
	}
}

02题:

Select Code
1
2
3
4
5
6
7
public class Demo02{
	public static void main(String[] args){
		for(int i=10;i>0;i--){
			System.out.println(i);
		}
	}
}

03题:

Select Code
1
2
3
4
5
6
7
8
9
public class Demo03{
	public static void main(String[] args){
		int sum = 0;
		for(int i=1;i<=10;i++){
			sum += i;
		}
		System.out.println("求1-10所有数之和:" + sum);
	}
}

04题:

Select Code
1
2
3
4
5
6
7
8
9
10
11
public class Demo04{
public static void main(String[] args){
	int sum = 0;
	for(int i=1; i<=100; i++){
		if(i%2==0){
			sum += i;
		}
	}
	System.out.println("求出1-100之间的所有偶数之和:" + sum);
}
}

05题:

Select Code
1
2
3
4
5
6
7
8
9
10
11
public class Demo05{
public static void main(String[] args){
	int sum = 0;
	for(int i=1; i<=100; i++){
		if(i%2==1){
			sum += i;
		}
	}
	System.out.println("求出1-100之间的所有奇数之和:"+sum);	//2500
}
}

06题:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
/*
求出5的阶乘;
公式:n!=n*(n-1)! 阶乘的计算方法 阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。 
*/
public class Demo06{
	public static void main(String[] args){
		int res = 1;
		for(int i=1; i<=5; i++){
			res = res * i;
		}
		System.out.println("5的阶乘:" + res);
	}
}

07题:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
求水仙花数;
所谓“水仙花数”是指一个三位数,其各位数字立方和等于该数 本身。
*/
public class Demo07{
	public static void main(String[] args){
		for(int i=100; i<1000; i++){
			int ge = i%10;		// 个位数
			int shi = i/10%10;	// 十位数
			int bai = i/100;	// 百位数
		
			if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
				System.out.println(i);
			}
		}
	}
}

08题:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
	列出5位数中的回文数
	回文数的概念:即是给定一个数,这个数顺读和逆读都是一样的。例如:121,1221...
*/
public class Demo08{
	public static void main(String[] args){
		int count = 0;
		for(int i=10000; i<100000; i++){
			// 个十百千万
			int ge = i%10; // 12345
			int shi = i%100/10;
			int qian = i%10000/1000;
			int wan = i/10000;
			
			if(ge==wan && shi==qian){
				count++;
				System.out.println(i);
			}
		}
		System.out.println("5位数中一共有"+count+"个回文数");	// 900
	}
}

09题:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
	统计1000以内,同时是3,5,7的倍数的数有多少个?
*/
public class Demo09{
	public static void main(String[] args){
		int count = 0;
		for (int i=0; i<1000; i++){
			if(i%3==0 && i%5==0 && i%7==0){
				System.out.println(i);
				count++;
			}
		}
		System.out.println("统计1000以内,同时是3,5,7的倍数的数有多少个?" + count);
	}
}

10题:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
在1-100之间,若是3的倍数,则在它之后输出中文“三”,若是5的倍数,则在它之后输出中文“五”,若是7的倍数,则在它之后输出中文“七”
*/
public class Demo10{
	public static void main(String[] args){
		for(int i=1; i<=100; i++){
			System.out.print(i);

			if(i%3==0){
				System.out.print("三");
			}else if(i%5==0){
				System.out.print("五");
			}else if(i%7==0){
				System.out.print("七");
			}

			System.out.println();
		}
	}
}

## 循环结构:while
while语句格式:

Select Code
1
2
3
4
5
[初始化部分]
while(条件表达式){
	循环体语句;
	[循环变量控制语句]
}

执行流程:

1. 执行初始化语句(如果有的话);
2. 判断条件表达式真假;如果真,往下执行;如果假,结束循环;
3. 执行循环体语句;
4. 执行循环变量控制语句(如果有的话);
5. 返回第2步,重复执行,直到条件为假,结束循环;

### 循环变量的使用问题:
for循环的循环变量,一般情况下在循环外是不能访问到的,因为它的作用域是在for循环的{}之内,但是可以通过把循环变量定义在循环之外来实现这个功能;或者定义计数器;

Select Code
1
2
3
4
5
6
7
8
9
10
for(int i=0;i<10;i++){
		...
	}
	System.out.println(i);	//error

	int i=0;
	for(;i<10;i++){
		...
	}
	System.out.println(i);	//ok

while循环本身就是把循环变量定义在循环之外,所以没有这个问题;

Select Code
1
2
3
4
5
6
int i=0;
	while(i<10){
		...
		i++;
	}
	System.out.println(i);

### for 和 while 的使用场景
1. 当明确知道循环的范围的时候,通常使用for;
2. 当不明确循环次数的时候,for和while都可以,通常使用while;

### 案例:
已知珠穆朗玛峰的高度是8848米,假设有一张足够大的纸,厚度是0.01米,请问:这张纸折叠多少次可以保证厚度不低于珠穆朗玛峰的高度?

答案:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
public class ZhuMuLangMa2{
		public static void main(String[] args){
			double h=0.01;
			double all_height = h;
			int count=0;
			while(all_height<=8848){
				all_height *= 2;
				count++;
			}
			System.out.println("需要折叠的次数是:"+count);
		}
	}

另外一种方法:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ZhuMuLangMa{
		public static void main(String[] args){
			double h=0.01;
			double all_height = h;
			int count=0;
			while(true){
				all_height *= 2;
				count++;
				if(all_height>8848){
					break;
				}
			}
			System.out.println("需要折叠的次数是:"+count);
		}
	}

## 循环结构:do-while
do while语句格式:

Select Code
1
2
3
4
5
[初始化部分]
	do{
		循环体语句;
		[循环变量控制语句]
	}while(条件表达式);

执行流程:

1. 执行初始化部分(如果有)
2. 执行循环体语句
3. 执行循环变量控制语句(如果有)
4. 判断条件表达式,如果为真,返回第2步;如果为假,结束循环

特点:循环体至少被执行1次;

### 三种循环的比较和死循环
– while和for可以互换;
– do-while循环的循环体语句至少执行一次;
– 优先选择使用for循环;
– 死循环:条件表达式永远为true;

## 循环的嵌套
外层循环表达式为真时,进入内层循环条件的判断,内层循环结束时,跳到外层循环继续判断外层循环的条件;

代码实例:

Select Code
1
2
3
4
5
6
7
8
9
10
public class QianTao{
		public static void main(String[] args){
			for(int i=0; i<5; i++){ //外层循环
				for(int j=0; j<5; j++){	//内层循环
					System.out.println(i+"*"+j);
				}
				System.out.println("-------");
			}
		}
	}

### 案例
循环嵌套打印正三角形、倒三角形;

代码:

Select Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
	打印三角形:第n行打印n次星号
	*/
	import java.util.Scanner;

	public class SanJiaoXing{
		public static void main(String[] args){
			Scanner s = new Scanner(System.in);
			System.out.println("请输入一个数字,表示三角形的行数:");
			int num = s.nextInt();
			
			for(int i=1; i<=num; i++){
				for(int j=i; j>0; j--){
					System.out.print("*");
				}
				System.out.println();
			}
		}
	}


备注:可以试试输出一个倒三角形。

#大数据学习笔记第3天# 运算符

## 回顾
1. 什么是关键字?java中的关键字的特点是什么?
2. 什么是标识符?标识符有哪些组成规则?
3. 什么是字面量常量?
4. Java中字面量常量有哪几种?
5. 十进制、二进制、八进制、十六进制之间的转换。
6. 如何求一个负数的表现形式?
7. 定义变量的两种格式。
8. Java中基本数据类型有哪些?各占用几个字节?
9. 什么是变量的作用域?
10. 显式类型转换的格式。

### 答案
1. 答:Java语言中已经被赋予特定意义的一些单词,不可以把这些字作为标识符来使用。特点:关键字全部使用小写字母。

2. 答:标识符可以简单地理解为一个名字,用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。标识符由任意顺序的字母、下划线、美元符号和数字组成,并且第一个字符不能是数字。标识符不能死Java中的保留关键字。

3. 答:在程序运行过程中一直不会改变的量称为常量,通常也称为“final变量”。常量在整个程序中只能被赋值一次。在为所有的对象共享值时,常量是非常有用的。

final 数据类型 常量名称[=值];

常量名通常使用大写字母,但并非是必须的,只是一种约定成熟的规定。

4. 答:字面常量分为:整型、布尔、浮点型、字符型、字符串、null。

5. 答:十进制转二进制,基数为2,转八进制基数为8,转十六进制基数为16;二进制转十进制:2^0, 2^1….;

6. 答:负数的规律。从右往左,遇到第1个1,往右原样,往左取反。

7. 答:方法1:数据类型 变量名=初值; 方法2:数据类型 变量名; 变量名=初值;

8. 答:基本数据类型:整型(byte[1], short[2], int[4], long[8])、浮点型(float[4], double[8])、字符型(char[2])、布尔型(boolean[1])。

9. 答:{}内的变量称为局部变量。局部变量只在当前代码块中有效。

10. 答:(byte,short,char)->int->long->float->double

## 思考题

## 第一节课
– 回顾
– 思考题
– 算术运算符

## 第二节课
– 赋值运算符
– 比较运算符
– 逻辑运算符

## 第三节课
– 位运算符
– 按位与按位或、异或操作
– 移位运算规律
– 三元运算符

## 第四节课
– 分支结构
– 从键盘录入数据
– 判断正负

## 运算符分类
– 算术运算符
– 赋值运算符
– 比较运算符
– 逻辑运算符
– 位运算符
– 三元运算符

### 算术运算符

### ++和–:
– 自加 (++)
– 放在变量前:先自增,再使用
– 放在变量后:先使用,再自增
– 自减 (–)
– 放在变量前:先自减,再使用
– 放在变量后:先使用,再自减

注意:只能对变量使用。

字符串参与运算:

1. 两个操作数都是字符串;
2. 一个字符串一个变量;
3. 多个操作数;

“+”除了字符串相拼接功能外,还能把非字符串转换成字符串,加空串即可。 String s = 5 + “”;

思考题:

Select Code
1
2
System.out.println("5+5="+5+5);	//5+5=55
System.out.println(5+5+"hello"); //10hello

### 算术运算符注意事项:
– 除法操作两个操作数是整数时,结果也是整数,余数部分舍弃;
– %操作获得的是除法操作的余数;%结果的符号取决于被模数,即%前面的数的符号决定了结果的正负。

实例:

Select Code
1
2
int x=3500;
System.out.println(x/1000*1000);	//3000

## 赋值运算符
– 符号:=,+=,-=,`*=`,/=,%=
– 左侧为变量,右侧为字面量,或变量,或表达式;

示例:

支持连续赋值:int a=b=c; a=b=c=3;
int a = 3; a += 5; // 等同于运算 a = a + 5;
扩展:+=,-=,`*=`,/=,%= 自动做强制类型转换。

Select Code
1
2
3
4
5
6
7
8
public class Demo{
	public static void main(String[] args){
		short s=5;
		//s = s + 5;	//错误: 不兼容的类型: 从int转换到short可能会有损失
		s+=5;	//+=运算符会强制类型转换,等同于 s+(short)5
		System.out.println(s);	//10
	}
}

## 比较运算符
– 操作数是常量、变量或表达式;
– 比较运算符的结果是boolean型,要么是true,要么是false,常用作条件判断。
– 比较运算符”==”不能写成”=”;

## 逻辑运算符
– 与:两个条件都是true才是true;
– 或:只要有一个条件是true就是true;
– 异或:两个操作数不一样,才是true;
– 短路与,短路或:在左侧的操作数决定整个表达式的值的时候,右侧的表达式不进行运算;

### 逻辑运算符小结:
– 逻辑运算符的操作数都是布尔型表达式;
– “&”和”&&”(短路与)的区别
– 单&时,左边无论真假,右边都进行运算;
– 双&时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算;
– 或”|”与”||”(短路或)同理,左边为真时,右边不参与运算;

总结:只有在右边需要运算时,才参与运算;

异或(^)与或(|)的区别:异或求的是异;或只需要一个为true结果就为true。

## 位操作符

## 三元运算符
(条件表达式)?表达式1:表达式2;

– 如果条件为true,整个表达式结果是表达式1;
– 如果条件为false,整个表达式结果是表达式2;
– 通常两个表达式同类型;
– 三元表达式整体是有值的,也就是说,它不能单独使用;要么直接打印,要么赋值;

### 示例:获取两个数中的最大值。

Select Code
1
2
int x=3, y=4;
int max = (x>y)?x:y;	//变量max存储的就是两个数的大数

## 程序流程控制
– 顺序结构
– 分支结构(选择结构) if, switch
– 循环结构(while, do…while, for)

### 程序流程控制
顺序结构:语句按照顺序依次执行,单纯的顺序结构的程序基本不存在。大型的程序从宏观上来看的话,各个模块之间也是呈现顺序结构。

### 分支结构:if
分支结构也称为选择结构,程序根据条件表达式的值来决定程序的走向。

Select Code
1
2
3
4
5
if(条件表达式)
{
	语句体;
}
...//其他语句

### 分支结构:if-else

Select Code
1
2
3
4
5
6
if(条件表达式){
	语句体1;
}else{
	语句体2;
}
...//其他语句

if语句注意事项:

– if后的括号内一定是布尔值或布尔表达式;
– 第二种格式与三元运算符的区别:三元运算符运算完要有值出现,并且可以写在其他表达式中;
– if的语句块中可以加多条语句,实现更复杂的逻辑
– if/else后边的大括号可以省略,此时if语句只能控制到另一个分号结束;如果有多条语句的话,不能省略;建议不要省略大括号;

### 分支结构:if-else if

Select Code
1
2
3
4
5
6
7
8
9
10
11
if(条件表达式1){
	语句体1;
}elseif(条件表达式2){
	语句体2;
}elseif(条件表达式3){
	语句体3;
}
...
else{
	语句体n;
}

### 分支结构:if-else练习
如何接收从键盘录入数据?

Select Code
1
2
3
import java.util.Scanner;
Scanner s=new Scanner(System.in);
s.nextInt();	//获取int值,用s.next()获取字符串

### 练习
1. 从键盘录入数据,使用程序判断正负;

2. 从键盘录入整数作为成绩,根据成绩显示提示:

– 60分以下显示“不及格”
– 60-79分显示“及格”
– 80-99分显示“优秀”
– 100分显示“满分”

3. 改进前面的程序,增加对非法成绩的处理;

4. 从键盘输入两个数,显示其中最大值,要求使用if-else结构

5. 从键盘输入三个数,显示其中最大值,要求使用if-else和三元表达式两种方式实现