Java的构造方法
面向对象：属性和方法，当对象被创建的时候，构造方法用来初始化该对象，给对象的成员变量赋初始值
构造方法的格式： 修饰符 构造方法名(参数列表){方法体}
写法: 1.方法名与他所在类的名字相同
2.没有返回值，所以不需要指定返回类型，也不需要void
注：无论你是否定义了构造方法, 所有类都有构造方法，因为Java自动为你提供了一个无参构造方法，一旦你自己定义了构造方法，Java自动提供的默认的无参构造方法就会失效。无参必须，有参建议。
如果你不提供构造方法，系统会默认给你一个无参构造方法
如果你提供了构造方法，系统不会给你提供一个无参构造方法
构造方法时可以重载的， 既可以定义参数，也可以不定义参数
案例：学生类
public class Student {
private String name;
private int age;
// 无参构造方法
public Student(){
// System.out.println("无参构造方法被调用");
}
//有参的构造方法，初始化学生类的时候
public Student(String name,int age){
this.age = age;
this.name = name;
System.out.println("有参构造方法被调用" + this.name);
}
}
JavaBean
JavaBean (爪哇 的 咖啡豆) 是一种Java的标准规范.
符合JavaBean的类要求类:1、必须是具体的和公共的 2、并且具有无参构造方法 3、提供用来操作成员变量的set和get方法， 和数据库中表字段对应的实体类就是一个典型JavaBean
案例：学生类JavaBean
package com.company;
public class StudentJavaBean {
// 成员变量
private String name;
private int age;
private int salary;
// 无参构造方法(必须)
public StudentJavaBean(){
}
// 有参构造方法(建议)
public StudentJavaBean(String name, int age){
this.name = name;
this.age = age;
this.salary = salary;
}
// 成员方法
// get***()
public String getName(){
return name;
}
// set***()
public void setName(String name){
this.name = name;}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public int getSalary(){
return salary;
}
public void setSalary(int salary){
this.salary = salary;
}
}
创建TestJavaBean
package com.company;
public class TestJavaBean {
// JavaBean 爪哇 的 咖啡豆 是一种Java的标准规范.
// 符合JavaBean的类要求类1、必须是具体的和公共的/2、并且具有无参构造方法
// 3、提供用来操作成员变量的set和get方法， 和数据库中表字段对应的实体类就是一个典型JavaBean
// 格式
// 成员变量
// 无参构造方法[必须]
// 有参构造方法[建议]
// 成员方法
// get***()
// set***()
public static void main(String[] args) {
// 无参的构造方法的调用
StudentJavaBean s = new StudentJavaBean();
s.setName("李白");
s.setAge(9999);
s.setSalary(6666);
System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getSalary());
// 有参的构造方法的调用
StudentJavaBean s2 = new StudentJavaBean("杜甫", 8888);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}
API
API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的字典 ，是JDK中提供给 我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。
API使用步骤:
1.打开帮助文档。
2.点击显示，找到索引，看到输入框。
3.你要找谁？在输入框里输入，然后回车。
4.看包。java.lang下的类不需要导包，其他需要。
5.看类的解释和说明。
6.学习构造方法。
7.使用成员方法。
Scanner类
Scanner类:一个可以解析基本类型和字符串的简单文本扫描器。
案例：读取通过键盘录入的数据
//创建对象 格式：数据类型 变量名 = new 数据类型(参数列表);
Scanner scanner = new Scanner(System.in);
//调用方法 格式：变量名.方法名();
int i = scanner.nextInt();
Scanner使用步骤
1.查看类
java.util.Scanner ：该类需要import导入后使用。
2.查看构造方法
public Scanner(InputStream source) : 构造一个新的 Scanner ，它生成的值是从指定的输入流扫描的。
3.查看成员方法
public int nextInt() ：将输入信息的下一个标记扫描为一个 int 值。
使用Scanner类，完成接收键盘录入数据的操作，代码如下：
//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {
public static void main(String[] args) {
//2. 创建键盘录入数据的对象
Scanner sc = new Scanner(System.in);
//3. 接收数据
System.out.println("请录入一个整数：");
int i = sc.nextInt();
//4. 输出数据
System.out.println("i:"+i);
}
}
案例：键盘录入两个数据并求和
package com.company;
import java.util.Scanner;
public class APIDemo02 {
public static void main(String[] args) {
//输入两位数求和
Scanner scanner = new Scanner(System.in);
System.out.println("请输入两个数(求和)：");
int num1 = scanner.nextInt();
int num2 = scanner.nextInt();
int sum = num1 + num2;
System.out.println(num1 + "+" + num2 + "的和为" + sum);
}
}
案例：键盘录入三个数据并获取最大值
package com.company;
import java.util.Scanner;
public class APIDemo1 {
public static void main(String[] args) {
// 1. Scanner类(System.in是指通过键盘录入数据)
// 除了java.lang包下的类不需要导入，其他必须导入才能使用
//导包格式： import 包名，类名;
//调用方法 变量名.方法名() + altEnter
// 2. Random类
// 3. ArrayList类
//三个数求最大值
Scanner scanner = new Scanner(System.in);
System.out.println("请输入三个数(求最大值)：");
int x = scanner.nextInt();
int y = scanner.nextInt();
int z = scanner.nextInt();
int max;
if(x >= y && x >= z){
max = x;
}else if (y >= x){
max = y;
}else{
max = z;
}
System.out.println("最大的数为：" + max);
}
}
匿名对象
匿名对象：没有变量名的对象。创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法，但是应用场景非常有限。
格式：
new 类名(参数列表)；
例： new Scanner(System.in)；
应用场景：
1.创建匿名对象直接调用方法，没有变量名。
new Scanner(System.in).nextInt();
2.一旦调用两次方法，就是创建了两个对象，造成浪费，请看如下代码。
new Scanner(System.in).nextInt();
new Scanner(System.in).nextInt();
一个匿名对象，只能使用一次。
3.匿名对象可以作为方法的参数和返回值作为参数
public static void main(String[] args) {
// 普通方式
Scanner sc = new Scanner(System.in);
input(sc);
//匿名对象作为方法接收的参数
input(new Scanner(System.in));
}
public static void input(Scanner sc){
System.out.println(sc);
}
}
//作为返回值
// 普通方式
Scanner sc = getScanner();
}
public static Scanner getScanner(){
//普通方式
//Scanner sc = new Scanner(System.in);
//return sc;
//匿名对象作为方法返回值
return new Scanner(System.in);
}
}
Random类
Random类：
1.查看类
java.util.Random ：该类需要 import导入使后使用。
2.查看构造方法
public Random() ：创建一个新的随机数生成器。
3.查看成员方法
public int nextInt(int n) ：返回一个伪随机数，范围在 0 (包括)和 指定值 n (不包括)之间的int 值。
案例：使用Random类，生成3个10以内的随机整数
//1. 导包
import java.util.Random;
public class Demo01_Random {
public static void main(String[] args) {
//2. 创建键盘录入数据的对象
Random r = new Random();
for(int i = 0; i < 3; i++){
//3. 随机生成一个数据
int number = r.nextInt(10);
//4. 输出数据
System.out.println("number:"+ number);
}
}
}
案例：猜数字，每次猜会提示数字大还是小
public class Test02Random {
public static void main(String[] args) {
Random random = new Random();
int number = random.nextInt(100)+1;
while (true){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您猜的数字：");
int i = scanner.nextInt();
if( i > number){
System.out.println("您猜的的数字大了");
}else if(i < number){
System.out.println("您猜的的数字小了");
}else{
System.out.println("恭喜您猜对了！！！");
break;
}
}
}
}
ArrayList类
ArrayList类:对象数组。java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList 中可不断添加元素，其大小也自动增长。
ArrayList使用步骤
1.查看类
java.util.ArrayList ：该类需要 import导入使后使用。
，表示一种指定的数据类型，叫做泛型。 E ，取自Element(元素)的首字母。在出现 E 的地方，我们使
用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。
代码如下：ArrayList，ArrayList
2.查看构造方法
public ArrayList() ：构造一个内容为空的集合。
3.基本格式:ArrayList list = new ArrayList();
4.在JDK 7后,右侧泛型的尖括号之内可以留空，但是<>仍然要写。简化格式：ArrayList list = new ArrayList<>();
5.查看成员方法
public boolean add(E e) ： 将指定的元素添加到此集合的尾部。
参数 E e ，在构造ArrayList对象时， 指定了什么数据类型，那么 add(E e) 方法中，只能添加什么数据
类型的对象。
案例:使用学生数组，存储三个学生对象
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
publicvoid setName(String name) {
this.name = name;
}
publicint getAge() {
return age;
}
publicvoid setAge(int age) {
this.age = age;
}
}
public class Test01StudentArray { public static void main(String[] args) { //创建学生数组
Student[] students = new Student[3];
//创建学生对象
Student s1 = new Student("曹操",40);
Student s2 = new Student("刘备",35);
Student s3 = new Student("孙权",30);
//把学生对象作为元素赋值给学生数组
students[0] = s1;
students[1] = s2;
students[2] = s3;
//遍历学生数组
for(int x=0; x
Student s = students[x];
System.out.println(s.getName()+"‐‐‐"+s.getAge());
}
}
}
案例：使用ArrayList类，添加三个字符串元素到集合中
public class Test02StudentArray {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
// 指定元素添加到集合的尾部
// list.add("张三");
// 创建刘、关、张、赵 四位同学的信息
StudentJavaBean s1 = new StudentJavaBean("刘玄德", 50);
StudentJavaBean s2 = new StudentJavaBean("关云长", 45);
StudentJavaBean s3 = new StudentJavaBean("张翼德", 42);
StudentJavaBean s4 = new StudentJavaBean("赵子龙", 41);
// 进行添加操作
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
// 打印list
System.out.println(list);
System.out.println(list.size());
// 遍历ArrayLisy的第一种方式fori 循环
for (int i = 0; i
// StudentJavaBean s = list.get(i);
// System.out.println(s.getName());
System.out.println(list.get(i).getName());
}
}
}
元素的增删改查和遍历
public boolean add(E e) ：将指定的元素添加到此集合的尾部。
public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
public class Demo01ArrayListMethod {
public static void main(String[] args) {
//创建集合对象
ArrayList list = new ArrayList();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//public E get(int index):返回指定索引处的元素
System.out.println("get:"+list.get(0));
System.out.println("get:"+list.get(1));
System.out.println("get:"+list.get(2));
//public int size():返回集合中的元素的个数
System.out.println("size:"+list.size());
//public E remove(int index):删除指定索引处的元素，返回被删除的元素
System.out.println("remove:"+list.remove(0));
//遍历输出
for(int i = 0; i < list.size(); i++){
System.out.println(list.get(i));
}
}
}
案例：生成6个1~33之间的随机整数,添加到集合,并遍历
public class Test01ArrayList {
public static void main(String[] args) {
// 创建Random 对象
Random random = new Random();
// 创建ArrayList 对象
ArrayList list = new ArrayList<>();
// 添加随机数到集合
for (int i = 0; i < 6; i++) {
int r = random.nextInt(33) + 1;
list.add(r);
}
// 遍历集合输出
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}