Java基础知识梳理—从配置环境变量到完成学生管理系统

在这里插入图片描述个人介绍


大家好我是:一颗松
认真分享技术,记录学习点滴
如果分享对你有用请支持我哦?

点赞:? 留言:✍收藏:⭐️

个人格言: 想法落实的最佳时机就是现在!?


初学须知
:::info
? 1. 常用百度
? 2. 一定要动手敲,并长时间坚持(第一遍可能会很难)
? 3. 多思考并自行实现功能代码
:::

1 java基础知识梳理

用思维导图,结构化展现java基础大概内容。

2 开发环境搭建

学习编程,必须有自己的开发环境

2.1 安装JDK

  1. 拓展知识:
  • java语言是跨平台语言,一套java代码可以去多个系统软件上运行(Windows、macOS、Linux…),但前提是需要在系统软件上安装有java运行环境(JRE);

    1. JRE:(java Runtime Environment)java运行环境,它**包含java虚拟机(JVM)**和一些标准类库;
    2. JVM:(Java Virtual Machine),java字节码文件(.class)在虚拟机上运行。java程序离不开java虚拟机。
    3. JDK: Java Development Kit,java语言开发工具包,包含java运行环境JRE和java工具
  • JDK、JRE、JVM三者之间是包含与被包含关系

  1. 安装JDK

    1. 打开浏览器输入甲骨文公司官网(https://www.oracle.com),在导航栏点击产品(Products)进入页面底部,选择java

在这里插入图片描述

  1. 进入java页面,翻到页面底部选择Orele JDK

在这里插入图片描述

  1. 进入下载页面根据需求下载
    在这里插入图片描述

  2. 安装过程一路next就可以(如果想修改安装目录,最好安装在纯英文目录下)

2.2 配置环境变量

  1. 为什么要配置环境变量?

答:因为在不配置环境变量的情况下,java的编译运行操作只能在java安装目录下进行,使得工作很难展开。(高版本JDK会自动配置环境变量,存在功能不全问题;建议手动配置)

  1. 配置工作
    1. 找到此电脑,右击选择属性

在这里插入图片描述

  1. 进入属性界面后选择高级系统设置

在这里插入图片描述

  1. 进入系统设置后选择高级,再选择环境变量设置

在这里插入图片描述

  1. 进入环境变量配置页面后在系统环境变量下,选择新建

在这里插入图片描述

  1. 新建JAVA_HOME并配置安装目录到jdk版本目录

在这里插入图片描述

  1. 在path环境变量下,添加新配置;配置内容:“%JAVA_HOME%bin”

在这里插入图片描述

在这里插入图片描述

到这里配置就算完成了。

  1. 怎么检查是否配置成功?

答:在键盘上,按住win键+R键 ,输入“cmd”;
然后在DOS窗口输入“java -version”如果有出现java版本信息,那么恭喜你成功啦
在这里插入图片描述


3 java基础语法

清楚基础语法知识对于后期学习是十分必要的,一点一点的必须搞懂;
注意:【java语言中对字母的大小写是严格区分的,大写和小写代表两个东西。】
我们先看一个完整java程序案例:

案例1 — HelloWord案例

public class HelloWord {
    public static void main(String[] args) {
        System.out.println("HelloWrod");
    }
}

3.1 标识符和关键字

  1. 什么是标识符?

标识符:java开发中用到的名字,就是各种名字:变量名、类名、包名等等;
案例1中:HelloWord是类名、main是方法名,args是变量名;这些都是标识符

名字呢不能乱起,那么该如何命名?【标识符的命名规则】

  • 只能由:数字、字母、下划线(_)和“$”组成!不能出现其他任何字符。
  • 不能以数字开头

江湖规则1: 小驼峰命名法,一个单词时全小写,多个单词时从第二个单词开始首字母大写,常见在(变量、方法名)
江湖规则2: 大驼峰命名法,每个单词首字母大写常见在(类名)话说不遵守江湖规则是行不通滴;

注意:【标识符要做到见名知意】

  1. 关键字是什么?

关键字:java中有特殊含义的单词,在高级记事本或者集成开发环境中都会用不同的颜色显示;不需要特意背知道常见,慢慢积累;

java常用关键字:

class public static private
break continue default import
if else for while
int short char double
float switch long return

3.2 常量和变量

常量和变量都描述的是数据,数据有不同的类型我们首先了解一下java中的数据类型

  1. 常量:就是值不会发生改变的数据,比如:2,‘a’,"java"等等

此处需要注意的是:

  • 浮点型常量:浮点型就是小数类型常量,小数默认是double类型,如果是float类型数值后必须加F或f
  • 字符型常量:用单引号括起来的的单个字符如:‘a’、‘6’、'A’等等;
  • 字符串常量:用双引号括起来的内容如:“helloword”、“15121”、" "等等;

注意:空字符串"",字符串的值为空;空字符’'会报错

  1. 变量:变量定义格式
  1. 数据类型 变量名;
  2. 数据类型 变量名 = 变量值;

3.3 运算符

  1. 算术运算符:
符合 含义
+、-、*、/ 与数学中使用方法一样
% 取模(也叫取余)
++、- - 自增、自减运算符

算术运算符注意事项【面试题】:

  • 以下语句会不会报错?为什么?
		short num1 = 10,num2;
        byte num3 = 20;
        num2 = num1+num3;      //第一句
        //---------------------------------------------------
        num2 = 200+30;			//第二句
        //-------------------------------------------------
        num3 = 120+10;		  	//第三句
        //-------------------------------------------------
        //解析
        /*
			第一句:会报错,这边存在一个隐式转换;【任何整型变量在计算时都会默认转为int类型】再做计算;此处num1与num3会先转int计算完再赋值,然而num2是short类型,大类型值赋值给小类型会报错;
			第二句:不会报错,此处存在常量优化机制,因为200与30都是常量,在编译过程中会将结果计算出来,再给num2赋值;num2是short类型230在它的范围内;所以不会出错;
			第三句:会报错,虽然java有常量优化机制,但是,此处优化后的结果是130,超出了byte的范围;【byte范围:-128----+127】
		*/
         
  1. 赋值运算符:
符号 含义
= 赋值运算符,将符号右边的值赋给左边变量
+= 加等
-= 减等
/= 除等
%= 取模等

赋值运算案例:

		int  num2  = 20;		//把 常量20赋给num2
		//-----------------------------------------------
		byte num3 = 20;
        num3 += 20;	//此处实质是:num3 = (num3类型)(num3+20)

注意: 【类似+=、-=、%=这样的赋值运算存在默认强制转换机制】

  1. 判断运算符:
符号 含义
==、!=、 等于、不等于
“>”、<、>=、<= 大于、小于、大于等于、小于等于
  1. 逻辑运算符:
符号 含义
&、!、 与、非
&& 短路与
|        // 逻辑或
^        // 逻辑异或
||		 // 短路或

两个变量值互换要求:不用第三方变量【面试题】:

  • 方案1 数学思维解决
 		int num1 = 20;
        int num2 = 30;
        num1 = num1+num2;
        num2 = num1-num2;
        num1 = num1-num2;
  • 方案2 用异或解决【一个数被另一个数连续异或两次,这个数值不变】
	    int num1 = 20;
        int num2 = 30;
        num1 = num1^num2;
        num2 = num1^num2;
        num1 = num2^num1;

4 数组

4.1 一维数组

1. 数组概念:
数组是一个可以存储多个相同数据类型的数据的容器;

2. 数组的定义与初始化

数据类型 [ ] 数组名;
数据类型 数组名 [ ];

3. 静态初始化,两种格式:

完整格式1
数据类型 [ ] 数组名 = new 数据类型[ ] { 数据1,数据2,数据3… };
简化格式2
数据类型 [ ] 数组名 = { 数据1,数据2,数据3… };

静态初始化 案例-1

        //数组定义初始化完整格式
        int [] arr1 = new int[]{1,2,3};
        //数组定义初始化简化格式
        int [] arr2 = {1,2,3};

4. 动态初始化格式

数据类型 [ ] 数组名;
数组名 = new 数据类型 [ 所需的存储空间];

动态初始化 案例-2

  int [] arr3;//定义数组
  arr3 = new int[10];//动态初始化
  arr3[0] = 15;
  arr3[1] = 20;
  .
  .
  .
  arr[9] = 9

5. 数组元素访问

  • 索引
    索引的概念:容器中空间的编号就是索引,索引值从0开始(容器中空间编号从0开始)
  • 元素:数组中存储的数据被称为

访问格式

格式:数组名 [索引值];
eg: int [] arr2 = {1,2,3};
arr2[0];
arr2[1];
注意:数组元素以索引值访问时只能,一个一个单独访问,不能同时出现多个索引值;

错误示例: arr2[0,1,2];

访问案例

 int [] arr2 = {1,2,3};
 System.out.println("arr2数组中第一元素为:"+arr2[0]);

6. 数组遍历
数组遍历:就是把数组中的每个元素,依次都访问一遍;

数组遍历,输出所有元素格式:

for (int i = 0; i < 数组长度; i++) {
System.out.println(“数组值:”+数组名[i]);
}

友情提示:【IDEA快捷键—生成遍历框架【 数组名 .fori +Enter 】

案例2—数组案例集

数组遍历输出 案例-3

int [] arr2 = {1,2,3};//定义,静态初始化数组
for (int i = 0; i < arr2.length; i++) {
    System.out.println("数组值:"+arr2[i]); //遍历输出arr2数组中的每个元素
}

求数组元素偶数和 案例-4

 int [] arr4 = {1,2,3,4};		 //静态初始化数组
        int sum =0;
        for (int i = 0; i < arr4.length; i++) {
            if (arr4[i]%2==0){	//通过取模筛选出所有偶数
                sum += arr4[i];	//累加计算偶数和
            }
        }
        System.out.println("数组元素中所有偶数和为:"+sum);	//输出偶数和

求数组元素中最大值 案例-5

 public static void main(String[] args) {
        int [] arr5 = {1,15,20,9,88,8}; //静态初始化数组
        for (int i = 1; i < arr5.length; i++) {
            if (arr5[0]<arr5[i]){ //筛选出大于arr5[0]的数
                arr5[0] = arr5[i];//将筛选出的数,赋值给arr5[0]
            }
        }
        int max = arr5[0];			//将arr5[0]赋值给max变量
        System.out.println("次数组最大值为:"+max);
    }

4.2 数组初始化内存分配图解

 public static void main(String[] args) {
        int [] arr = new int [7]; //动态初始化一个长度为10的数组
    }

方法区: java中字节码文件会存在方法区;【注意:字节码文件不调用不加载】
栈内存: java把内存分为两部分,栈内存和堆内存,基本类型变量存于栈内存,栈内存存储特点,先进栈的内容后出栈;
堆内存: 所有new出来的东西存放在堆内存中。
在这里插入图片描述
当arr的值为null时,再访问arr数组元素时,就会出现空指针异常,报错如下:

Exception in thread "main" java.lang.NullPointerException
	at HelloWord.main(HelloWord.java:8)

4.3 二维数组

二维数组就是,一维数组的元素时一维数组;也就是数组存数组,这边不详细展开


5 流程控制

流程控制在各编程语言中通用,所以这是必须要掌握的第4点内容

5.1 顺序结构

程序默认是按照从上往下的顺序,执行流程;

5.2 分支结构

5.2.1 if语句(判断条件最终必须为:布尔类型值)

  1. 简单if语句格式:

语句格式:
if (判断条件){
语句体; //判断条件成立执行语句体;
}

int nub1 = 1;
int nub2 = 2;
if(nub1>nub2){
       System.out.println("执行了语句体");  //判断条件为false,此语句不执行;
}
  1. if…else语句格式

语句格式:
if (判断条件){
语句体1; //判断条件成立执行语句体1;
}else{
语句体2; //判断条件不成立执行语句体2;
}

int nub1 = 1;
int nub2 = 2;
if(nub1>nub2){
       System.out.println("执行了语句体1");  //判断条件为false,此语句不执行体;
}else{
       System.out.println("执行了语句体2");  //判断条件为false,执行此语句体;
}
  1. if…else if…else…语句格式

语句格式:
if (判断条件1){
语句体1; //判断条件成立执行语句体1;
}else if(判断条件2){
语句体2; //判断条件1不成立,判断条件2成立,执行语句体2;
}else{
语句体3; //判断条件1和2都不成立执行语句体3;
}

案例3—成绩奖励(if案例)

/*
考试奖励:
    分数>=90:奖励自行车一辆
    90>分数>=80:奖励游乐园一日游
    80>分数:一顿狂揍
*/
public class IfTest {
    public static void main(String[] args) {
        int chengji;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入成绩:");
           chengji = sc.nextInt();
           if (chengji <=100 && chengji>=0){
               if (chengji>=90){
                   System.out.println("恭喜!奖励自行车一辆!");
               }else if (chengji>=80 && chengji<90){
                   System.out.println("恭喜!奖励游乐园一日游!");
               }else{
                   System.out.println("来吧一顿接受狂揍!");
               }
           }else{
               System.out.println("成绩输入有误!");
           }
    }
}

5.2.2 switch语句
switch语句格式:如下伪代码所示

 switch(variable){
           case 1:
               语句体1;
               break;
           case 2:
              语句体2;
               break;
           case 3:
               语句体3;
               break;
               .
               .
               .
           default:
               默认语句;
               break;
       }
  1. variable的取值范围
  • 基本类型:byte、short、int、long
  • 引用类型:jdk5开始,允许枚举类型;jdk7开始,允许String
  • jdk14开始允许,一个case 后跟多个值:case 1,2,3:
  • if与switch选用:范围性的判断用if更合理;switch更适合固定值判断;
  1. case穿透(可以优化代码)

case穿透示例:如果有多个重复的语句体可以使用case穿透

switch(variable){
    case 1:
    case 2:
    case 3:
        //重复语句体;
        break;
    default:
        break;
}
  1. jdk14以后新特性(可以优化代码)

case穿透示例:如果有多个重复的语句体可以使用case穿透

switch(variable){
    case 1,2,3:
        //重复语句体;
        break;
    default:
        break;
}

案例4 — 成绩录入输出评价(switch案例)

等级 评语
A 成绩良好
B 成绩中等
C 及格
D 成绩不合格
System.out.println("请输入成绩:可选项【A、B、C、D】");
        switch ('B') {
            case 'A':
                System.out.println("成绩良好");
                break;
            case 'B':
                System.out.println("成绩中等");
                break;
            case 'C':
                System.out.println("及格");
                break;
            default:
                System.out.println("成绩不合格!");
                break;
        }

switch语句执行流程:
第一步:拿variable值与case值对比,如果对比结果相等,则进入语句体,直到遇到break;或者执行结束才会退出switch语句;
第二步:如果在case中没有匹配到值,就会进入default语句,直到遇到break;或者执行结束才会退出switch语句。在switch语句中 执行顺序与case 、default的位置无关;

知识拓展【三目运算符:】

三目运算符格式:
判断条件 ? 值1 : 值2;

执行流程:
1 判断条件是否为真?
2 如果判断条件为真,则 值1 赋给这这条语句的结果;
3 如果判断条件为假,则 值2 赋给这这条语句的结果;

案例5—三目运算符操作案例:

public void  operator(){
    int a,b,c;
    a = 10;
    b = 20;
    //第一种情况判断条件(b>a)为真
    c = b>a ? a:b;//c的值为10;
    //第二种情况判断条件(b<a)为假
    c = b<a ? a:b;//c的值为20;
}

5.3 循环结构

使用循环的条件:

某个操作需要重复执行多次


5.3.1 for循环

  1. for循环的使用
//for循环格式:

    for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }
//在for循环中,初始化语句只执行1次;
//for循环案例:
 public static void main(String[] args) {
        for(int i =0;i<3;i++){
            System.out.println("执行第"+i+"次循环!");
        }
    }
  1. for循环执行流程(重中之重)
 for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }


注意:【在for循环中初始化语句只执行一次】

案例6 — 求100以内偶数和(for循环案例)

//for循环案例3(1-100之间的偶数和)
//实现方案1
        int sum =0;
        for (int i = 1;i<=100;i++){
            if (i%2==0){
                sum += i;
            }
        }
        System.out.println("1-100之间偶数和为:"+sum);
//实现方案2
        int sum =0;
        for (int i = 2;i<=100;i+=2){
                sum += i;
        }
        System.out.println("1-100之间偶数和为:"+sum);

案例7 — 打印所有水仙花数(for循环)

需求分析:什么是水仙花数?
答:水仙花数是一个三位数,它的每个位上的数字的 3次幂之和等于它本身。
步骤分析:

1 通过for循环筛选出三位数
2 通过if按照水仙花数概念,晒出水仙花数

  //for循环找出水仙花数
        for (int i=100;i<=999;i++){
            int ge,shi,bai; //定义各位、十位、百位变量准备后续操作
            ge = i%10;
            shi = i/10%10;
            bai = i/100;
            //用if对水仙花数条件进行筛选
            if (i==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                System.out.println("水仙花数:"+i);
            }
        }

6 java中的方法

6.1方法的概念与功能

方法概念:具有独立功能的代码块【在其他语言中也叫函数】
方法作用:
a. 按功能将代码分类,提高代码可读性
b. 方便后期代码维护
c. 提高代码复用性

IDEA涨知识:Ctrl + F12,打开类的大纲

6.2 方法定义格式:

6.2.1 方法定义格式:
无参方法定义格式:

修饰符 返回值类型 方法名(){
return 返回值;
}

带参方法定义格式:

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2){
return 返回值;
}

6.2.3 形参(形式参数)与实参(实际参数)

形参:定义方法时声明的参数
实参:调用时传入的实际参数

//形参
public static void prints(int num) { //此处的 num就是形参
     //方法体语句
 }
//main方法调用prints()方法时需要传实参
 public static void main(String[] args) {
          prints(5);				//此处5就是实际参数
 }

案例8— 方法定义


//1无参方法
    public static void prints() {
        System.out.println("*******************");
    }

//2带参方法
    //案例1 主方法:
        public static void main(String[] args) {
                //方法体语句
        }
    //案例2 自定义方法:
         public static int sum(int num1,int num2){
                int sum = num1+num2;
                return sum;//返回值
         }

6.3 自定义方法的位置:

方法与方法之间保持平级关系,方法不允许嵌套定义;

6.4 方法的调用与执行:

方法不调用不执行:
方法的执行顺序与编写顺序无关,只与调用顺序相关;

方法的调用方式1: 用类名直接调用,被static修饰的方法,属于类所有,可以直接用:类名.方法名(); 直接调

方法的调用方式2: 通通对象调用,对象名.方法名();

6.5 方法调用内存图解

6.6 java方法的值传递与址传递

问题:在java中方法传参到底是值传递还是址传递?
答:java参数传递问题需要分情况讨论:

  • 传递的参数为基本类型,则是值传递;
  • 传参为引用类型参数,就是址传递;
  1. 基本数据类型

案例1:【问:num1的值会不会变? 答:不会】

  public static void main(String[] args) {
        int num1 = 100; //定义变量num1
        test1(num1);    //把num1,作为参数传给test1方法
        System.out.println(num1);
    }
    public static int test1(int num1){
        return num1 = 200; //在test1方法中,给num1重新赋值
    }

基本数据类型作为参数的内存图解:


2. 引用类型数据

案例1:【问:num1的值会不会变? 答:会】

  public static void main(String[] args) {
        int [] num1 = {10,11}; //定义数组num1
        test1(num1);    //把num1地址,作为参数传给test1方法
        System.out.println(num1[0]);
    }
    public static int test1(int [] num1){
        return num1[0] = 200; //在test1方法中,给num1[0]重新赋值
    }

引用类型数据作为参数的内存图解:

案例9— 定义方法做输出

 public static void prints(int freq) {
        if(freq<0 ){
            System.out.println("输入次数有误,请重新输入:");
        }else {
            for (int i = 0; i < freq; i++) {
                System.out.println("学好编程!");
            }
        }
    }

7 初识面向对象

面向对象是java语言的一大特征,也是java学习分水岭,理解掌握好这块基础对后期学习而言非常必要

7.1 类与对象

7.1.1. 类是什么?
答:类是把一类事物的属性,行为抽象成一个java文件,用文件来表现这类事物,那么这个文件就是一个类;
7.1.2. 对象是什么?
答:对象是类的一个具象,比如:通过一个描述所有人特征的类,可以具象出某一个具体的人如张三;通过人类产生的这个张三,就是人类的一个对象;
7.1.3. 类的特征
a. 类包含成员变量和成员方法
定义在类中的变量:叫成员变量
定义在方法中的变量:叫局部变量

成员变量 成员变量是对同一类事物共同属性的一个抽象
成员方法 成员方法是对同一类事物共同行为的一个抽象

7.1.4. 类的定义
定义格式:

修饰符 class 类名{
成员变量;
成员方法;
}

案例9 ----定义学生类

public class Students {
   int age;         //学生类成员变量age
   String name;     //学生类成员变量name
   void speak(){    //学生类成员方法speak
       System.out.println("大家好!我是"+name+"今年"+age+"岁");
   }
}

【注意:】类定义时,class前的public有什么用?
答:public修饰的类有最大权限,大家都可以访问,程序的主类必须用public修饰;被public修饰的类,类名与文件名必须保持一致,否则报错;

7.1.5. 对象的创建和使用
对象的创建格式:

类名 对象名 = new 类名();

案例10—根据案例9创建学生对象张三

public static void main(String[] args) {
        Students zhangsan = new Students();		//创建学生对象张三
        zhangsan.age = 18;									//用对象为成员方法赋值
        zhangsan.name = "张三";							
        zhangsan.speak();										//用对象调用成员方法
    }

7.2 构造方法

构造方法又叫构造器

是在构建、创造对象的时候调用的方法,(没有构造方法不能创建对象)
注意:【一个类中如果没有手动写构造方法,系统会默认提供一个无参构造方法】

7.2.1. 构造方法格式

  • 构造方法名 与类名相同
  • 没有返回值类型,连void也没有
  • 没有具体返回值,不能使用return带回结果

注意:【在构造方法中“return;”是可以存在的,this代表当前类对象的地址,谁调用代表谁】

案例1-构造方法格式

class Students{	  //创建Students类
    String name;  //成员变量name
    int age;      //成员变量age
    //无参构造方法
    Students(){}
    //带参构造方法
    Students(int age,String name){ 
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

7.2.2. 构造方法的作用

2.1 本质作用是用于创建对象
2.2 可以在创建对象的时候,直接给成员变量赋值

案例2–通过构造方法为成员变量赋值

public class ThisDemo {
    public static void main(String[] args) {
        Students stu1 = new Students(18,"小明"); //创建对象stu1,并传参
    }
}
class Students{
    String name;  //成员变量
    int age;      //成员变量
    Students(int age,String name){ //构造方法
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

7.2.3. 构造方法内存解析(案例2解析)

注意:【字节码文件不调用不加载】

7.3 java面向对象的特征

话说java万物皆对象,怎么理解呢?
答:生活中的所有事务我们都可以进行归类,归类后就能找出共性,共同属性,共同行为等等那么就可以将事物抽象成类;一个类可以创建无数对象,这样就便于开,发节省开发成本。也就是万物皆对象。
7.3.1 java的封装
什么是封装?

答:大概可以这么理解,就好比公开且无人管的器材室,所有人都可以随意出入,里面篮球?、足球⚽、羽毛球?等等器材大家都可以自由使用想怎么用就怎么用。封装就是现在来了一个管理员器材室不能随意出入了,你要东西可以,但是不能让你自己随意拿了,得经过管理员之手。(这段纯属我自己理解的,有问题欢迎在评论区指正)

a. 此处公开就对应权限修饰:public,被public修饰的属性用最大权限,可以被任意class调用;
b. 不公开就对应:private,被private修饰的属性只能在本类内部使用,外部无法直接访问,但是可以通过类提供的public修饰的方法间接访问。

为什么要封装?封装有什么好处?

  1. 外部不能直接访问、提高代码的安全性,可控性更方便管理;
  2. 降低程序复杂度。

案例11—学生类的封装案例


public class Studens {
    private int age;        //定义成员变量 age并私有
    private String naem;    //定义成员变量 name并私有

    public Studens() {      //无参构造
    }

    public Studens(int age, String naem) {  //带参构造
        this.age = age;
        this.naem = naem;
    }

    public void speak(){
        System.out.println("讲中国话");     // 成员方法
    }

    public int getAge() {                  //为外部提供变量访问的方法getXxx方法
        return age;
    }

    public void setAge(int age) {           //为外部提供变量访问的方法setXxx方法
        this.age = age;
    }

    public String getNaem() {               //为外部提供变量访问的方法getXxx方法
        return naem;
    }

    public void setNaem(String naem) {      //为外部提供变量访问的方法setXxx方法
        this.naem = naem;
    }
}

继承、多态java进阶补充;
7.3.2 java的继承

7.3.3 java的多态


8 初识javaAPI

javaAPI(Application Programming Interface)应用程序编程接口

8.1JavaAPI帮助文档的使用方法

什么是API?
答:API本质就是java为开发者提供的工具类,这些类功能强大,为开发工作提供得力助手。
如何学习API?
答:需要阅读官方提供的API开发文档;
阅读步骤:

  1. 打开开发文档,在导航栏选择索引选项,输入自己想要查询的类名:

在这里插入图片描述

  1. 查看类是不是在java.lang包下,如果是则使用是不需要导包,不是则要导包;

在这里插入图片描述

  1. 接着看类的介绍,可以做什么;
  2. 看构造方法,因为构造方法是我们创建对象时候必须用的,根据构造方法创建对象;
  3. 看成员方法;

8.2 String类的介绍

  • 在java中所有被“”包裹的内容都是String类的对象;

  • 字符串一旦被创建,则值就不会发生改变;

  • 字符串常量池:
    JDK8之前常量池在方法区
    JDK8以后被迁移到堆内存

案例12----字符串常量池面试题

回答问题并说明原因:

 public static void main(String[] args) {
        boolean flag;
        //第一题
        String str1 = "hello";
        String str2 = new String("hello");

        flag = str1 == str2 ;
        System.out.println("第一题,输出为true还是false?:"+flag);

        //第二题
        String str3 = "hello";
        flag = str1 == str3;
        System.out.println("第二题,输出为true还是false?:"+flag);
    }

解析:①此处涉及到字符串常量池知识,在用“”直接创建字符串对象时,首先会到字符串常量池中查找是否有该字符串,如果有直接从常量池中把地址拿给字符串常量,如果没有则往常量池中添加新元素。
②用new方法创建字符串对象时,在栈内存开辟变量空间后,再到堆内存new出一块新空间,此时拿参数字符串对象去常量池中复制一份赋值给new出来的空间,再将空间地址赋给字符串变量;

  • String类的常见方法
方法 功能
boolean equals(Object anObject) 比较两个字符串是否相等
boolean equalsIgnoreCase(String anotherString) 比较两个字符串是否相等(忽略大小写)
char [] toCharArray() 将字符串转换为一个新的字符数组

案例13—自定义方法统计指定字符在本字符串中出现的次数

public static int countChar(String String, char cha) {
        int count = 0;                          
        char []arr = String.toCharArray();      //使用String类的toCharArray方法将字符串转为字符数组
        for (int i = 0; i < arr.length; i++) {  //for循环遍历数组
            if (cha == arr[i]){                 //if语句对比字符,用count统计
                count ++;
            }
        }
        return count;                           //返回统计数
    }

8.3 Random类

方法 含义
int nextInt(int n) 返回一个伪随机数,它是取自此随机数生成器序列的、在 0(包括)和指定值(不包括)之间均匀分布的 int 值。

规则简单记:【包左不包右】

案例14—java小游戏【猜数字】

public static void numGame() {
        int count = 3;                                    //控制循环次数
        Random r = new Random();
        int num = r.nextInt(100)+91;               //生成0---100的随机数
                Scanner sc = new Scanner(System.in);
        while (count > 0){                               //循环控制输入次数
            System.out.println("请输入1--100的随机数值:");
            int numb = sc.nextInt();
            if (num==numb) {
                System.out.println("恭喜您猜对啦!");
                break;
            }else if (numb<num){
                System.out.println("您猜的数偏小,您还有"+(count-1)+"次机会!");
                count --;
            }else {
                System.out.println("您猜的数偏大,您还有"+(count-1)+"次机会!");
                count --;
            }
        }
    }

9 初识集合

9.1 ArryList集合

  • ArrayList构造方1
    • public ArrayList();
  • 泛型:<>
    • 在类名之后加<>,可以使集合存储的数据类型,进行类型限制;
    • 尖括号中只能使用引用数据类型,不能是基本数据类型

解决方案:【基本类型都有对应包装类】

基本数据类型 对应包装类
int Integer
short Short
byte Byte
double Double
float Float
char Character

1 ArrayList的常用成员方法

    • public boolean add(E e);向集合尾部添加数据,返回添加成功的状态
    • public void add(int index,E element);插队添加
 ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素

    • public E remove(int index);根据索引删除集合中的元素
    • public boolean remove(元素);根据元素删除集合中的内容,重复元素只删除第一个;返回添加成功的状态
 ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.remove("张三");                //根据元素删除
        list1.remove(2);                    //根据索引值删除元素

    • public E set(int index,E element);修改指定索引位置,返回被覆盖的元素
ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                   //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");  
        list1.set(2,"年薪百万");             //修改集合数据

    • public E get(int index);根据索引,获取集合中的元素
      ArrayList<String> list1 = new ArrayList<>();//创建集合
        list1.add("张三");                        //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.get(2);                           //查找集合元素

案例15 ----ArrayList初使用

创建一个存储字符串集合,存储5个字符串元素,找出4个字的人名,并打印

 public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                           //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        for (int i = 0; i < list1.size(); i++) {    //遍历集合
            String name = list1.get(i);             //获取集合元素
            if (list1.get(i).length()==4){          //判断字符串长度是否为4
                System.out.println(name);           //打印4个字的名字
            }
        }
    }

学生管理系统实现

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>