视频地址：点击访问
（我这里开发工具有时候用eclipse有时候用IDEA，看每个人的习惯）
（文中代码部分不会和老师讲的一模一样，因为我都是在看到老师给的案例后自己尝试写的，推荐大家这样做，可以帮助大家掌握）
是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。
我们想要运行一个已有的Java程序， 那么只需安装JRE即可。
是Java程序开发工具包，包含JRE和开发人员使用的工具。
其中的开发工具:编译工具(javac.exe)和运行工具(java.exe) 。
我们想要开发一个全新的Java程序，那么必须安装JDK。
开发Java程序,需要使用JDK提供的开发工具，而这些工具在JDK的安装目录的bin目录下。
为了在开发Java程序的时候，能够方便的使用javac和java这些命令，我们需要配置Path环境变量。
开发Java程序，需要三个步骤:编写程序，编译程序,运行程序
空常量不能直接输出
名字不能重复
变量未赋值，不能使用
long类型的变量定义的时候，为了防止整数过大，后面要加L
float类型的变量定义的时候，为了防止类型不兼容，后面要加F
●由数字、字母、下划线( )和美元符($)组成
●不能以数字开头
●不能是关键字
●区分大小写
小驼峰命名法:方法、变量
●约定1:标识符是一个单词的时候，首字母小写
●范例1:name
●约定2: 标识符由多个单词组成的时候，第一个单词首字母小写,其他单词首字母大写
●范例2: firstName
大驼峰命名法:类
●约定1: 标识符是一个单词的时候，首字母大写
●范例1: Student
●约定2: 标识符由多个单词组成的时候,每个单词的首字母大写
●范例2: GoodStudent
把一个表示数据范围小的数值或者变量赋值给另-个表示数据范围大的变量
范例: doubled = 10;
把一个表示数据范围大的数值或者变量赋值给另-个表示数据范围小的变量
●格式:目标数据类型变量名= (目标数据类型)值或者变量;
●范例: intk = (int)88.88;
package test;
public class test {
public static void main(String[] args) {
int i = 0;
char c = 'A';//'A'的值是65
System.out.println(i + c);
}
}
结果：
提升规则:
package test;
public class test {
public static void main(String[] args) {
System.out.println("hello"+"earth");
System.out.println("hello"+ 6666);
System.out.println(6666+ "hello");
System.out.println("hello"+6+666);
System.out.println(6+666+"hello");
}
}
结果：
红色的运算符隐含着强制类型转换
单独使用
package test;
public class test {
public static void main(String[] args) {
//单独使用
int i = 1;
System.out.println("i="+i);
i++;
System.out.println("i="+i);
++i;
System.out.println("i="+i);
}
}
结果：
参与操作使用
package test;
public class test {
public static void main(String[] args) {
int i = 1;
System.out.println("i="+i);
//参与操作使用
int j = i++;
System.out.println("i="+i);
System.out.println("j="+j);
}
}
结果：
package test;
public class test {
public static void main(String[] args) {
int i = 1;
System.out.println("i="+i);
//参与操作使用
int j = ++i;
System.out.println("i="+i);
System.out.println("j="+j);
}
}
结果：
区别：
注意事项:
逻辑与&，无论左边真假，右边都要执行。
短路与&&，如果左边为真,右边执行;如果左边为假，右边不执行。
逻辑或|，无论左边真假，右边都要执行。
短路或||，如果左边为假，右边执行;如果左边为真，右边不执行。
计算规则:
首先计算关系表达式的值
如果值为true，表达式1的值就是运算结果如果值为false，表达式2的值就是运算结果
package test;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println("i="+i);
sc.close();//关闭sc接口
}
}
结果：
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
if (a % 2 == 0)
System.out.println("a是偶数");
else
System.out.println("a是奇数");
sc.close();
}
}
结果：
输入一个数字判断是什么季节
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
switch (i) {
case 1:
System.out.println("春季");
break;
case 2:
System.out.println("春季");
break;
case 3:
System.out.println("春季");
break;
case 4:
System.out.println("夏季");
break;
case 5:
System.out.println("夏季");
break;
case 6:
System.out.println("夏季");
break;
case 7:
System.out.println("秋季");
break;
case 8:
System.out.println("秋季");
break;
case 9:
System.out.println("秋季");
break;
case 10:
System.out.println("冬季");
break;
case 11:
System.out.println("冬季");
break;
case 12:
System.out.println("冬季");
break;
default:
System.out.println("输入不合法");
break;
}
sc.close();
}
}
利用case穿透性
//case穿透
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
switch (i) {
case 1:
case 2:
case 3:
System.out.println("春季");
break;
case 4:
case 5:
case 6:
System.out.println("夏季");
break;
case 7:
case 8:
case 9:
System.out.println("秋季");
break;
case 10:
case 11:
case 12:
System.out.println("冬季");
break;
default:
System.out.println("输入不合法");
}
sc.close();
}
}
public class test {
public static void main(String[] args) {
//先找到100——999
for(int i = 100;i < 1000;i++) {
//判断条件
int a = i % 10;
int b = i / 10 % 10;
int c = i / 100 % 10;
if(a*a*a+b*b*b+c*c*c == i) {
System.out.println(i);
}
}
}
}
结果：
public class test {
public static void main(String[] args) {
int i = 0;
double hou = 0.1;
while(hou <=8844430) {
i++;
hou = hou*2;
}
System.out.println(i);
}
}
结果：
作用：产生一个随机数
package test;
import java.util.Random;
import java.util.*;
public class test1 {
public static void main(String []args ) {
Random r = new Random();
int num = r.nextInt(100)+1;
System.out.println(num);
Scanner sc = new Scanner(System.in);
while(true) {
int num1 = sc.nextInt();
if(num > num1) {
System.out.println("需要猜大一点");
}else if(num < num1) {
System.out.println("需要猜小一点");
}else {
System.out.println("猜对了，你真厉害");
break;
}
}
}
}
结果：
数组(array)是一种用于存储多个相同类型数据的存储模型
Java中的数组必须先初始化然后才能使用
所谓初始化:就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
动态初始化和静态初始化
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
public class test1 {
public static void main(String []args ) {
int[] arr = new int [5];
//输出数组名
System.out.println(arr);
//输出数组元素
System.out.println(arr[0]);
}
}
结果：
Java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
***这里arr指向的是内存地址，这个内存地址是首地址（数组首地址）***
静态初始化:初始化时指定每个数组元素的初始值，由系统决定数组长度
public class test1 {
public static void main(String []args ) {
int[] arr = {1,2,3};
int[] arr1 = {3,2,1};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr1);
System.out.println(arr1[0]);
}
}
结果：
public class test1 {
public static void main(String []args ) {
int[] arr = new int[3];
System.out.println(arr);
System.out.println(arr[0]);
arr = null;
System.out.println(arr);
System.out.println(arr[0]);
}
}
结果：
发生空指针异常，当arr = null时，指针不再有指向。
public class test1 {
public static void main(String []args ) {
int[] arr = {1,2,3,4,5,6};
for(int i = 0;i < arr.length;i++) {
System.out.println(arr[i]);
}
}
}
结果：
public class test1 {
public static void main(String []args ) {
//获取最值
//定义一个数组
int[] arr = {3,1,2,4};
//定义存放最大值,令他等于数组第一个元素
int max = arr [0];
//循环比较找出真正的最大值
for(int i = 1;i < arr.length;i++) {
if(max <= arr[i]) {
max = arr[i];
}
}
System.out.println(max);
}
}
结果：
方法(method)是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
注意：
public class test1 {
public static void main(String []args ) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
//函数调用
isnumber(a);
sc.close();
}
//定义判断是否是偶数的方法
public static void isnumber(int i) {
if(i % 2 == 0) {
System.out.println("是偶数");
}else {
System.out.println("不是偶数");
}
}
}
结果：
public class test1 {
public static void main(String []args ) {
int[] arr = {1,5,2,3,7};
getmax(arr);
}
//获取数组中最大数
public static void getmax(int i[]) {
int max = i[0];
for(int a = 1;a < i.length;a++) {
if(max <= i[a]) {
max = i[a];
}
}
System.out.println(max);
}
}
结果：
定义方法时，要做到两个明确
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
###重载实例
需求:使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型(byte,short,intlong)
public class test1 {
public static void main(String []args ) {
boolean a = compare(1,2);
System.out.println(a);
boolean c = compare((byte)1,(byte)2);//类型转换
System.out.println(c);
boolean b = compare(2.0,2.0);
System.out.println(b);
}
//定义比较两个数字是否相同
public static boolean compare(int a,int b) {
System.out.println("int");
return(a == b);
}
public static boolean compare(double a,double b) {
System.out.println("double");
return(a == b);
}
public static boolean compare(byte a,byte b) {
System.out.println("byte");
return(a == b);
}
}
结果：
了解形参与实参可以参考其它作者文章：点击查看
基本类型和引用类型的区别：基本数据类型在声明时系统就给它分配空间；而引用数据类型不同，它声明时只给变量分配了引用空间，而不分配数据空间。
通常 基本类型 和 String 传递是值传递，形参的改变不会影响实参的改变
对于基本数据类型的参数。形式参数的改变，不影响实际参数的值
结果：
理解
在调用change方法的时候，知识将main方法中的值传给对应的形式参数，函数接收的是原始值的一个拷贝， 此时内存中存在两个相等的基本类型，后面方法中的操作都是对形参这个值的修改，不影响实际参数的值。
对于引用类型的参数，形式参数的改变，影响实际参数的值
结果：
理解
在调用change方法的时候，形参和实参都指向相同的内存地址，所以对形参的修改就是对所指向地址空间数据的修改，此时实参也会发生改变
public class test1 {
public static void main(String []args ) {
int[] arr = {1,2,4,5,3,6,9};
show(arr);
}
public static void show(int[] a) {
System.out.print("[");
for(int i = 0;i < a.length;i++) {
if(i == a.length-1) {
System.out.print(a[i]);
}else {
System.out.print(a[i]+",");
}
}
System.out.print("]");
}
}
结果：
Debug调试，又被称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看
这一部分难度不大，建议自己看视频操作一下，很容易掌握
这里我想在视频的基础上实现输入的不是数字，而是”星期一“这样的字符串，但在进行字符串比较时出现了问题，如下图：
当我在控制台输入”星期一“后，显示如下图：
并没有像我想的一样成功打印出”跑步“，之后我进行debug发现，没有进行进入循环，说明不符合判断条件，但在我理解中应该是符合判断条件的，这时我把判断条件单独拿出来运行：
当我在控制台输入”星期一“时，输出false
看来不符合判断条件，这里使用连等号不能达到我们的目的
经过搜索资料我发现： 连等号在比较基本数据类型时比较的是值即以下类型比较时是比较的值。具体深入理解java中==和equals的用法可以查看其它作者的文章：点击查看
修改后：
最终可以达到目的，这里只做部分的代码呈现，大家可以自己完整做一下，亲手做才会有收获哦，发现问题解决问题。
public class test {
public static void main(String[] args) {
int[] arr = new int[20];
arr[0] = 1;
arr[1] = 1;
for (int i = 2;i < arr.length;i++){
arr[i] = arr[i-2] + arr[i-1];
}
System.out.println(arr[19]);
}
}
结果：
这里我没有采用视频中奖的方法，视频中的方法可以去具体看一下老师讲的（第93个问题）
这里我没有对三种鸡的数量进行分析，只是令所有的数量都小于100，if后用来写约束条件
结果：
但是这里我遗忘了一个条件，小鸡仔的数量卖的时候必须是三个三个卖的，因此小鸡仔的数量必须是3的倍数
由此我做出改进
结果：
public class test {
public static void main(String[] args) {
//定义两个数组
int[] arr = {1,2,3,4};
int[] arr1 = {1,2,3,4};
System.out.println(compare(arr,arr1));
}
public static boolean compare(int[] a,int[] b){
//当长度不同时不需要一一比较就可以判断
if (a.length != b.length){
return false;
}
for(int i = 0;i < a.length;i++){
if (a[i] != b[i]){
return false;
}
}
return true;
}
}
结果：
public class test {
public static void main(String[] args) {
//1:定义一个数组，用静态初始化完成数组元素的初始化
int[] arr = {1,2,3,4};
//2:循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
for (int start=0,end = arr.length-1;start<=end;start++,end--){
//3:变量交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
show(arr);
}
//4:遍历数组
public static void show(int[] a) {
System.out.print("[");
for(int i = 0;i < a.length;i++) {
if(i == a.length-1) {
System.out.print(a[i]);
}else {
System.out.print(a[i]+",");
}
}
System.out.print("]");
}
}
结果：
万物皆对象，客观存在的事物皆为对象
类是对现实生活中一类具有共同属性和行为的事物的抽象
(类在现实中不存在)
类的特点:
属性:对象具有的各种特征，每个对象的每个属性都拥有特定的值
行为:对象能够执行的操作
类:类是对现实生活中一类具有共同属性和行为的事物的抽象
对象:是能够看得到摸的着的真实存在的实体
package com.java;
public class PhoneDemo {
public static void main(String[] args){
//创建对象
Phone p = new Phone();
//使用成员变量
System.out.println(p.brand);
System.out.println(p.price);
p.brand = "华为";
p.price = 2999;
System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendMessage();
}
}
结果：
结果：
查看堆和栈的相关信息可以看其它作者的文章：点击查看
结果：
什么时候使用this呢? 解决局部变量隐藏成员变量
Student类写作这样
在运行测试类后结果是：
因为在setAge方法中指代不清楚，导致认为age都是局部变量。进行如下修改
用this来指代成员变量就会避免冲突，达到预想的效果。结果：
1.封装概述
是面向对象三大特征之一(封装，继承，多态)
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
2.封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxox()/setXxx()方法
3.封装好处
通过方法来控制成员变量的操作，提高了代码的安全性把代码用方法进行封装，提高了代码的复用性
结果：
可能大家会疑问，为什么之前没有给出构造方法，仍然可以这样使用上述语句：那是因为在没有给出构造方法的时候，系统默认给出无参构造方法。
结果：
做好下边实例可以带大家充分了解构造方法：
类
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;
}
//set/get方法
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//成员方法
public void show(){
System.out.println(name+age);
}
}
测试类
public class StudentTest {
public static void main(String[] args){
//无参构造方法，再使用setXX赋值
Student a = new Student();
a.setName("小怪兽");
a.setAge(12);
a.show();
System.out.println("____________");
//带参构造方法直接创建有属性的对象
Student b = new Student("奥特曼",100);
b.show();
}
}
结果：
帮助文档的使用可以查看我最上边给出的视频中的讲解，个人比较喜欢直接百度搜索。
注意:
调用方法的时候，如果方法有明确的返回值，我们用变量接收可以手动完成，也可以使用快捷键的方式完成(Ctrl+Alt+V)
public class test {
public static void main(String[] args){
//String构造方法:
//public string( ):创建一个空白字符串对象，不含有任何内容
String a = new String();
System.out.println("a:"+a);
//public String(char[] chs):根据字符数组的内容，来创建字符串对象
char[] arr = {'a','b','c'};
String b = new String(arr);
System.out.println("b:"+b);
//public String(byte[] bys):根据字节数组的内容，来创建字符串对象
byte[] arr1 = {99,98,97};
String c = new String(arr1);
System.out.println("c:"+c);
// 没有使用构造方法，String s =“abc”;直接赋值的方式创建字符串对象，内容就是abc
String d = "coco";
System.out.println("d:"+d);
}
}
结果：
但是推荐使用直接赋值方式
上面的代码中，JVM会首先创建一个字符数组，然后每一次new的时候都会有一个新的地址，只不过s1和s2参考的字符串内容是相同的
想看具体==和equal()的用法可以参考我前边给到的讲解：点击跳转
public class test {
public static void main(String[] args){
char[] arr = {'a','b','c'};
String s1 = new String(arr);
String s2 = new String(arr);
String s3 = "abc";
String s4 = "abc";
System.out.println(s1==s2);
System.out.println(s1==s3);
System.out.println(s3==s4);
System.out.println("````````````````````````");
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));
}
}
结果：
我的代码和课程上的有一点点出入，可以都尝试一下
public class test {
public static void main(String[] args){
//预先给出用户名和密码
String name = "小怪兽";
String code = "123abc";
for(int i = 1;i <= 3;i++){
Scanner sc = new Scanner(System.in);
System.out.println("输入用户名：");
String name1 = sc.nextLine();
System.out.println("输入密码：");
String code1 = sc.nextLine();
if (name.equals(name1)&&code.equals(code1)){
System.out.println("成功登录！欢迎"+name);
break;
}else if (name.equals(name1)){
System.out.println("密码输入错误");
}else if (code.equals(code1)){
System.out.println("用户名输入错误");
}else{
System.out.println("用户名和密码输入错误");
}
}
}
}
结果：
import java.util.Scanner;
public class test1 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("输入一个字符串：");
String s = sc.nextLine();
for(int i = 0;i < s.length();i++){
//获取指定索引处的char值
char a = s.charAt(i);
System.out.print(a+" ");
}
}
}
结果：
import java.util.Scanner;
public class test1 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("输入一个字符串：");
String s = sc.nextLine();
int bigcount = 0;
int smallcount = 0;
int numbercount = 0;
for (int i = 0;i < s.length();i++){
char a = s.charAt(i);
if (a >='A'&& a<='Z'){
bigcount++;
}else if (a >= 'a' && a <= 'z'){
smallcount++;
}else if (a >= '0' && a <= '9'){
numbercount++;
}
}
System.out.println("大写字母："+bigcount);
System.out.println("小写字母："+smallcount);
System.out.println("数字："+numbercount);
}
}
结果：
public class test2 {
public static void main(String[] args){
//预先初始化一个数组
int[] arr = {2,5,2,7};
//调用方法
String n = show(arr);
System.out.println(n);
}
//定义一个方法来输出
public static String show(int[] a){
String s = "[";
for (int i = 0;i <a.length;i++){
if (i == a.length-1){
s = s + a[i];
}else{
s = s + a[i]+",";
}
}
s = s + "]";
return s;
}
}
结果：
最后有一个案例是字符串反转，和前边的数组反转有异曲同工之妙，大家可以自己尝试一下
如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费内存空间，而这种操作还不可避免。那么有没有一种比较好的方式可以解决这个问题呢?答案是肯定的，我们可以通过Java提供的StringBuilder类就来解决这个问题。
StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器
这里的可变指的是StringBuilder对象中的内容是可变的
String和StringBuilder的区别:
String:内容是不可变的StringBuilder:内容是可变的
结果：
结果：
这里可以明显的看出来，a,b是同一个对象。帮助我们很好的理解了什么是返回对象本身。
结果：
结果：
因为append()返回的是对象本身，而对象可以调用方法，所以可以连续调用，让返回值作为对象调用方法
结果：
1.StringBuilder转换为String
publicString toString():通过 toString()就可以实现把StringBuilder转换为String
2.String转换为StringBuilder
public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
结果：
可以从输出的结果看出来toString()可以实现把StringBuilder转换为String
结果：
一开始我没有想到通过转换最终用String接收结果，下面是我的方法：
public class test1 {
public static void main(String[] args){
//初始化数组
int[] arr={2,3,4,5};
System.out.println(combine(arr));
}
//定义拼接字符串方法
public static StringBuilder combine(int[] a){
StringBuilder s = new StringBuilder();
s.append("[");
for (int i = 0;i < a.length;i++){
if (i == a.length-1){
s.append(a[i]);
}else {
s.append(a[i]).append(",");
}
}
s.append("]");
return s;
}
}
结果：
改进后：
package stringbulider;
public class test1 {
public static void main(String[] args){
//初始化数组
int[] arr={2,3,4,5};
String s = combine(arr);
System.out.println(s);
}
//定义拼接字符串方法
public static String combine(int[] a){
StringBuilder s = new StringBuilder();
s.append("[");
for (int i = 0;i < a.length;i++){
if (i == a.length-1){
s.append(a[i]);
}else {
s.append(a[i]).append(",");
}
}
s.append("]");
String c = s.toString();
return c;
}
}
这里我没有使用方法，无法复用
package stringbulider;
import java.util.Scanner;
public class test2 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("输入一段字符串：");
String a = sc.nextLine();
//把它转化为StingBulider后使用
StringBuilder s = new StringBuilder(a);
System.out.println(a+"字符串反转结果为："+s.reverse());
}
}
结果：
构造方法后：
import java.util.Scanner;
Scanner sc = new Scanner(System.in);
System.out.println("输入一段字符串：");
String a = sc.nextLine();
String b = change(a);
System.out.println(a+"字符串反转结果为："+ b);
}
public static String change(String a){
return new StringBuilder(a).reverse().toString();
}
}
集合类的特点:提供一种存储空问可变的存储模型，存储的数据容量可以发生改变集合类有很多，目前我们先学习一个: ArrayList
结果：
public boolean remove(0bject o):删除指定的元素，返回删除是否成功
结果：
结果：
public E remove(int index):删除指定索引处的元素，返回被删除的元素
结果：
结果：
这里出现了索引越界
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
结果：
public E get(int index):返回指定索引处的元素
结果：
package com.collection;
import java.util.ArrayList;
public class test {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
array.add("小怪兽");
array.add("奥特曼");
array.add("哈利波特");
System.out.println("array:"+array);
for (int i = 0;i < array.size();i++){
//这里视频是采用的用字符串接受
System.out.println("第"+(i+1)+"个元素是："+array.get(i));
}
}
}
结果：
package com.collection;
import java.util.ArrayList;
public class test2 {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> array = new ArrayList<Student>();
//创建学生对象
Student a = new Student("coco",11);
Student b = new Student("小怪兽",11);
Student c = new Student("奥特曼",22);
//添加学生对象到集合中
array.add(a);
array.add(b);
array.add(c);
for (int i = 0;i < array.size();i++){
Student s = array.get(i);
System.out.println("第"+(i+1)+"个学生："+s.getName()+" "+s.getAge());
}
}
}
结果：
package com.collection;
import java.util.ArrayList;
import java.util.Scanner;
public class test2 {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> array = new ArrayList<Student>();
//创建学生对象
addStudent(array);
addStudent(array);
addStudent(array);
for (int i = 0;i < array.size();i++){
Student s = array.get(i);
System.out.println("第"+(i+1)+"个学生："+s.getName()+" "+s.getAge());
}
}
public static void addStudent(ArrayList<Student> array){
Scanner sc = new Scanner(System.in);
System.out.print("输入名字：");
String name = sc.nextLine();
System.out.print("输入年龄：");
String age = sc.nextLine();
Student s = new Student();
s.setName(name);
s.setAge(age);
array.add(s);
}
}
结果：
当我们从键盘上循环输入一段字符串时要采用next()而不是nextLine()，因为nextLine()上次输入的值后会有/n会被下次循环输入时接受，错误判定为结束，会出现跳过现象。
Student.java
package system;
public class Student {
//学号
private String sid;
//姓名
private String name;
//年龄
private String age;
//居住地
private String address;
public Student(){}
public Student(String sid,String name,String age,String address){
this.sid = sid;
this.name = name;
this.age = age;
this.address = address;
}
public void setSid(String sid){
this.sid = sid;
}
public String getSid(){return sid;}
public void setName(String name){
this.name = name;
}
public String getName(){return name;}
public void setAge(String age){
this.age = age;
}
public String getAge(){return age;}
public void setAddress(String address){
this.address = address;
}
public String getAddress(){return address;}
}
main.java
package system;
import java.util.ArrayList;
import java.util.Scanner;
public class main {
public static void main(String[] args) {
//集合对象
ArrayList<Student> array = new ArrayList<Student>();
while(true){
MainInterfance();
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
switch (num){
case 1:
System.out.println("添加学生");
addStudent(array);
break;
case 2:
System.out.println("删除学生");
deleteStudent(array);
break;
case 3:
System.out.println("修改学生");
alterStudent(array);
break;
case 4:
System.out.println("查看所有学生");
showStudent(array);
break;
case 5:
System.out.println("感谢您的使用！");
System.exit(0);
}
}
}
//主页面
public static void MainInterfance(){
System.out.println("-------------欢迎来到学生管理系统-------------");
System.out.println("1.添加学生");
System.out.println("2.删除学生");
System.out.println("3.修改学生");
System.out.println("4.查看所有学生");
System.out.println("5.退出");
System.out.println("请输入你的选择：");
}
//添加学生
public static void addStudent(ArrayList<Student> array){
System.out.print("请输入你想添加学生的个数：");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
for (int i = 1;i <= num;i++){
System.out.println("输入添加的第"+i+"个学生的信息");
String sid;
while (true){
System.out.println("输入学号：");
sid = sc.next();
boolean a = decide(sid,array);
if (a){
System.out.println("该学号已存在，请重新输入！");
}else {
break;
}
}
System.out.println("输入姓名：");
String name = sc.next();
System.out.println("输入年龄：");
String age = sc.next();
System.out.println("输入居住地：");
String address = sc.next();
Student s = new Student();
s.setSid(sid);s.setAge(age);s.setName(name);s.setAddress(address);
array.add(s);
}
System.out.println("添加成功！");
}
//删除学生
public static void deleteStudent(ArrayList<Student> array){
Scanner sc = new Scanner(System.in);
System.out.println("输入你想删除的学生的学号：");
String sid = sc.next();
for (int i = 0;i < array.size();i++){
Student s = array.get(i);
if (s.getSid().equals(sid)){
array.remove(i);
break;
}else{
System.out.println("您输入的学生不存在！");
break;
}
}
}
//修改学生
public static void alterStudent(ArrayList<Student> array) {
Scanner sc = new Scanner(System.in);
System.out.println("输入你想修改的学生的学号：");
String sid = sc.next();
System.out.println("输入新姓名：");
String name = sc.next();
System.out.println("输入新年龄：");
String age = sc.next();
System.out.println("输入新居住地：");
String address = sc.next();
Student s = new Student();
s.setSid(sid);s.setAge(age);s.setName(name);s.setAddress(address);
for (int i = 0; i < array.size(); i++) {
Student student = array.get(i);
if (student.getSid().equals(sid)) {
array.set(i,s);
break;
}
}
}
//查看学生
public static void showStudent(ArrayList<Student> array){
if (array.size() == 0){
System.out.println("当前没有学生，请先添加学生。");
}
System.out.println("学号 "+" 姓名 "+" 年龄 "+" 居住地");
for(int i = 0;i < array.size();i++){
Student s = array.get(i);
System.out.println(s.getSid()+" "+s.getName()+" "+s.getAge()+" "+s.getAddress());
}
}
//判断学号重复
public static boolean decide(String sid,ArrayList<Student> array){
boolean a = false;
for (int i = 0;i < array.size();i++){
Student s = array.get(i);
if(sid.equals(s.getSid())){
a = true;
break;
}
}
return a;
}
}
结果：（添加和查看）
结果：（删除和修改）
继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法
好处：
在子类方法中访问一个变量
super关键字的用法和this关键字的用法相似
this:代表本类对象的引用
super:代表父类存储空间的标识(可以理解为父类对象引用)
随着我的学习更新