JAVA面向对象笔记（1-3）

最新推荐文章于 2024-07-26 12:28:02 发布

nulxv

最新推荐文章于 2024-07-26 12:28:02 发布

阅读量142

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_63592157/article/details/128914349

版权

1.1 java运行环境

Java语言： Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级编程语言。所谓编程语言，是计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。 Java语言发展史： ·1995年Sun公司发布Java1.0版本 ·1997年发布Java1.1版本 ·1998年发布Java1.2版本 ·2000年发布Java1.3版本 ·2002年发布Java1.4版本 ·2004年发布Java 5版本 //更新力度大 ·2006年发布Java 6版本 ·2009年Oracle甲骨文公司收购Sun公司，并于2011年发布Java 7版本 ·2014年发布Java 8版本 //更新力度大 ·2017年9月发布Java 9版本 ·2018年3月发布Java 10版本

位(bit)：一个数字0或者一个数字1，代表一位。
字节(Byte)：每逢8位是一个字节，这是数据存储的最小单位。
1Byte = 8bit
1PB = 1024TB
1EB = 1024PB
1ZB = 1024EB

启动：Win+R

切换盘符：盘符名称：

进入文件夹：cd 文件夹名称

进入多级文件夹：cd 文件夹1\文件夹2\文件夹3

返回上一级：cd ..

返回根目录：cd \

Java虚拟机： JVM（Java virtual machine）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java最具吸引力的特性之一。跨平台：任何软件的运行，都必须要运行在操作系统上，而用Java编写的软件可以运行在任何的操作系统上，称为Java的跨平台特性。该特性是由JVM实现的，编写的程序运行在JVM上，而JVM运行在操作系统上。 JRE和JDK: JRE（Java runtime environment）:是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。// 运行Java程序 JDK（Java Development Kit）:是Java程序开发工具包，包含JRE和开发人员使用的工具。// 开发Java程序 IDE Intergrated Development Environment 集成开发环境
java的虚拟机本身不具有跨平台的功能，每个操作系统本身都有不同版本的虚拟机。

path环境变量新建 在系统 - 关于里面 win+i

下方，JAVA_HOME 选择bin路径的上一级

编辑path， %JAVA_HOME%\bin;

1.1.1 HelloWorld案例

编写 HelloWorld.java
编译cmd javac HelloWorld.java -生成.class文件
运行cmd java HelloWorld

 public class HelloWorld{ // public class 后面代表定义一个类的名称，类是java当中所有源代码的基本组织的单位。
     public static void main(String[] args){ // 第二行的内容是万年不变的固定写法，代表main方法，程序的起点
         System.out.println("HelloWorld!!!"); // 第三行代表打印输出文件（屏幕显示）
     }
 }

1.1.2 关键字&标识符

关键字的特点
- 完全小写的字母
- 在增强版的记事本中，有特殊颜色
标识符：是指在程序中，我们自己定义的内容，如类的名字、方法的名字和变量的名字等，都是标识符。
- HelloWorld案例中，出现的标识符有类名字HelloWorld
命名规则：（硬性要求）
- 标识符可以包含英文26个字母、0-9数字、$和_。
- 标识符不能以数字开头
- 标识符不能是关键字
命名规范：（软性要求）
- 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）
- 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）
- 方法名规范：同变量名

1.1.3 常量&变量

常量的分类：

字符串常量
整数常量
浮点数常量
字符常量
布尔常量
空常量不能用来直接打印

基本数据类型

整数型 byte short int long
浮点型 float double
字符型 char
布尔型 boolean

引用数据类型

字符串、数组、类、接口、Lambda

注意事项：

字符串不是基本类型，而是引用类型
浮点型可能只是一个近似值，并非精确的值
数据范围与字节数不一定相关，例如float与long
浮点数当中默认类型为double，如果一定要用float，需要加上一个后缀F(推荐)
如果是整数，默认为int类形，如果一定要使用long类型，需要加上一个后缀L(推荐)

使用变量时注意事项

如果创建多个变量，变量之间的名称不能够重复
对于float和long来说后缀F和L不能够丢掉
如果使用byte和short类型的变量，右侧的值不能够超过左侧的值的范围
没有进行赋值的变量不能够直接使用
变量的使用不能超出作用域的范围

【作用域】从定义变量的一行开始，一直到直接果蔬的大括号结束为止
可以通过一个语句创建多个变量，但是不推荐。

1.1.4 数据类型转换

数据类型转换

自动类型转换(隐式)

特点：代码不需要进行特殊处理，自动完成

规则：数据范围从小到大

 long num = 100
 long       int 
 此刻发生了从int-->long，即数据范围从小到大，自动类型转换
 其中float的范围比long的范围要大一些

强制类型转换(显示)

特点：代码需要进行特殊的格式处理，不能自动完成
格式：范围小的类型范围小的变量名 = (范围小的类型) 原本范围大的数据
```
 int num = (int) 100L;
```

注意事项：

强转类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出

 int类型最多只能表示21个亿
 int num = (int) 6000000000L;
 此时编译器编译不会有错误，但是会发生数据溢出
 最后程序运行的结果为1705032704
 
 int num1 = (int) 3.5;
 此时运行结果为：3，精度损失

byte/short/char这三种类型都可以发生数学运算，都会被首先提升为int类型，然后再计算

 byte num1 = 40;
 byte num2 = 50;
 
 byte result = num1 +num2; // 此时num1与num2已经被转换为int类型了，相加后的结果也为int类型，因此这个语句在进行编译时会报错
 int result = num1 + num2; // 此时这个语句并不会报错
 
 short num3 = 60;
 short result2 = (short)(num1 + num2); // 此时要保证结果并不会超过short的数据范围

boolean类型不能发生数据类型转换

ASCII码表 // 美国信息交换标准代码

0 -- 48
A -- 65
a -- 97

Unicode码表：万国码。也是数字和符号的对照关系，开头0-127部分和ASCII完全一样，但是从128开始包含有更多的字符

1.1.5 运算符

一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种

加法

对于数值来说，就是加法
对于字符char类型来说，在计算之前，char会被提升为int，然后计算。char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode

对于字符串String(首字母大写，不是关键字)来说，加号代表字符串连接操作。任何数据类型和字符串进行连接时，结果都会变为字符串。

 System.out.println("Hello"+"World"); // HelloWorld
 System.out.println("Java"+20); // Java20
 System.out.println("Java"+20+30); // Java2030
 System.out.println("Java"+(20+30)); // Java50

只有变量才能使用自增、自减运算符，常量不可发生改变，所以不能用。

 byte num = 30;
 // num = num + 5;
 // num = byte + int;
 // num = int + int;
 // num  = (byte)int; // 编译器会自动的做一个强制类型转换
 num += 5;
 System.out.println("num");

与“&&”，或“||”，具有短路效果，如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。

三元运算符

格式：数据类型变量名称 = 条件判断？表达式A ：表达式B;

 int a = 10;
 int b = 20;
 int max = a > b ? a : b;
 
 int result = 3 > 4 ? 2.5 : 10; // 此时程序会报错
 **冒号“：” 左边和右边都必须满足 前面的数据类型的要求。**
 三元运算符的结果必须被使用
 a > b ? a : b; // 这是错误的写法。

1.1.6 方法入门

 public static void 方法名(){
     方法体
 }
 
 调用： 方法名();

方法的定义不能产生嵌套关系

1.1.7 JDK9新特性

jshell

进入：jshell
使用：System.out.println("yuju");
退出：/exit

用于轻量级使用。

对于byte/short/char三种类型

如果没有超过左侧的范围，编译器自动补上强转
否则，直接编译器报错

编译器的常量优化

在给变量进行赋值的时候，如果右侧的表达式当中全部都是常量，没有任何变量，那么编译器javac将会直接将若干个常量表达式计算得到结果。

 short a = 5;
 short b = 8;
 short result = a + b; // 此时编译器会直接报错， short --- int
 
 short result1 = 5 + 8; // 等号右边全都是常量，没有任何变量参与，编译之后，得到的.class字节码文件当中相当于【直接就是】：short result1 = 13;
 右侧的常量结果数值，没有超过左侧范围

1.1.8 选择结构-if语句-switch语句

Switch语句：

 int num  = 1;
 switch(num){
     case 1:
         System.out.println("今天是星期一");
         break;
     default:
         System.out.println("今天是星期八");
         break；
 }

注意事项：

switch后面小括号当中只能是下列数据类型：
- 基本数据类型：byte/short/char/int
- 引用数据类型：String字符串、enum枚举
switch语句格式可以很灵活，前后顺序可以颠倒，而且break语句可以省略

1.1.9 循环结构-for-while-do..while

循环语句

初始化语句：在循环开始最初执行，而且制作一次
条件判断：如果成立，则循环继续，否则，退出
循环体：重复要做的事情内容，若干行语句
步进语句：每次循环之后都要进行的扫尾工作

for循环的变量在小括号当中定义，只有循环内部才可以使用，while循环和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用。

1.1.10 开发工具-IDEA

idea网站：jetbrains

1.2 面向对象和封装

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节

面向对象：当需要实现一个功能的时候，不关心具体的步骤，二是找一个已经具有该步骤的人，来帮我做事

 int[] array = new int[]{5, 15, 30, 20, 10000};
       System.out.println(Arrays.toString(array));
 // 使用面向对象功能，便可以自动打印出这个格式的数组
 [5, 15, 30, 20, 10000]

特点：面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承、多态。

什么是类

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性和行为特征来描述该类事物。

现实中，描述一类事物：
属性：就是该事物的状态信息
行为：就是该事物能够做什么

什么是对象：

对象：是一类事物的具体体现。对象是一个类的一个实例，必然具备该事物的属性和行为。

类和对象的关系

类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体

成员变量：对应事物的属性

成员方法：对应事物的行为

注意事项：

成员变量时直接定义在类当中的，在方法外面
成员方法不要写static关键字

如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

 package cn.study.day29.demo02;
 
 import javax.swing.plaf.synth.SynthOptionPaneUI;
 
 /*
 通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用
 
 1、导包：也就是指出需要使用的类，在什么位置。
 import 包名称.类名称;
 import cn.study.day29.demo02.Student;
 
 2、创建 格式
 类名称 对象名 = new 类名称();
 Student stu = new Studnet();
 3、使用 分为两种情况：
 使用成员变量：对象名.成员变量名
 使用成员方法：对象名.成员方法名（参数）
 
 */
 public class Student {
     // 成员变量
     String name;
     int age;
 
     // 成员方法
     public void eat() {
         System.out.println("今天下课早，干饭!!!");
     }
 
     public void sleep() {
         System.out.println("今天没有早八，睡觉");
     }
 
     public void study() {
         System.out.println("该期末考试，开始学习！！！！！！");
     }
 
     public static void main(String[] args) {
         Student stu = new Student();
         System.out.println("学生的名字为：" + stu.name); // null
         System.out.println("学生的年龄为：" + stu.age); // 0
         System.out.println("==================");
         stu.name = "伍六七";  
         stu.age = 21;
         System.out.println("学生的名字为：" + stu.name); // 伍六七
         System.out.println("学生的年龄为：" + stu.age); // 21
         stu.eat();
    
         stu.sleep();
         stu.study();
     }
 }

参数在方法调用的时候，必然会被赋值的

 public void method(int param){
     System.out.println("param"); // 此时可以正常输出param，虽然param是一个局部变量，但是参数在方法调用的时候，必然会被赋值的。  
 }

局部变量和成员变量：

定义的位置不一样【重点】
- 局部变量：在方法的内部
- 成员变量：在方法的外部，直接写在类当中
作用范围不一样【重点】
- 局部变量：只有在方法当中才可以使用，出了方法就不能使用
- 成员变量：整个类全都可以通用
默认值不一样【重点】
- 局部变量：没有默认值，如果想要使用，需要手动赋值
- 成员变量：如果没有赋值，会有默认值，规则和数组一样
内存的位置不一样(了解)
- 局部变量：位于栈内存
- 成员变量：位于堆内存
生命周期不一样(了解)
- 局部变量：随着方法进栈而诞生，随着方法出栈而消失
- 成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

面向对象三大特征：封装、继承、多态

封装性在java中的体现：

方法就是一种封装
关键字private也是一种封装

封装就是将一些细节信息隐藏起来，对外界不可见。

 问题描述：定义Person的年龄时，无法阻止不合理的值被赋进来。
 
 解决方案：用private关键字将需要保护的成员变量进行修饰
 
 
 
 一旦使用了private进行修饰，那么本类当中仍然可以随意访问，但是！超出了本类就不能直接访问了
 
 package cn.study.day30.demo01;
 
 public class Person {
     String name;
     private int age;
 
     public void setAge(int age) {
         this.age = age;
     }
 
     public int getAge() {
         return age;
     }
 
     public void printlnPerson() {
         System.out.println("姓名" + name + " 年龄 " + age);
     }
 
     public static void main(String[] args) {
         Person p = new Person();
         p.printlnPerson();
         p.name = "迪丽热巴";
         p.setAge(20);
         p.printlnPerson();
     }
 }

 对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx的规则不变
 package cn.study.day30.demo01;
 
 public class Student {
     private String name;
     private int age;
     private boolean male;
 
     public void setMale(boolean male) {
         this.male = male;
     }
 
     public boolean isMale() {
         return male;
     }
 
     public void setName(String string) {
         name = string;
     }
 
     public String getName() {
         return name;
     }
 
     public void setAge(int age1) {
         age = age1;
     }
 
     public int getAge() {
         return age;
     }
 }

通过谁调用的方法，谁就是this

 package cn.study.day30.demo02;
 
 /*
 构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
 格式：
 public 类名称(参数类型 参数名称){
     方法体
 }
 注意事项：
 1、构造方法的名称必须和所在的类名称完全一致，包括大小写
 2、构造方法不要写返回值类型，连void都不要写
 3、构造方法不能return一个具体的返回值
 4、如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法体，什么事情都不做
 public Student () {}
 5、一旦编写了至少一个构造方法，那么，编译器将不再赠送
 构造方法也有重载
 
 */
 public class Student {
     // 成员变量
     private String name;
     private int age;
 
     // 无参数的构造方法
     public Student() {
         System.out.println("无参构造方法执行");
     }
 //    有参数的构造方法
     public Student(String name, int age) {
         this.name = name;
         this.age = age;
         System.out.println("有参构造函数执行");
     }
 //  Getter Setter
     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;
     }
 }
 
 package cn.study.day30.demo02;
 
 public class Demo02Student {
     public static void main(String[] args) {
         Student one = new Student();
         Student two = new Student("毛利兰",19);
 
     }
 }

一个标准的类通常要拥有下面四个组成部分

1.所有的成员变量都要使用private关键字修饰 2.为每一个成员变量编写一对Getter/Setter方法 3.编写一个无参数的构造方法 4.编写一个全参数的构造方法

这样标准的类也叫做Java Bean

 package cn.study.day30.demo03;
 /*
 
 */
 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;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getAge() {
         return age;
     }
 
     public void setAge(int age) {
         this.age = age;
     }
 }
 
 package cn.study.day30.demo03;
 
 public class Demo03Student {
     public static void main(String[] args) {
         Student one = new Student();
         Student two = new Student("毛利兰", 19);
         one.setAge(9);
         one.setName("矮冬瓜娃柯南");
         System.out.println("姓名：" + one.getName() + " 年龄：" + one.getAge());
         System.out.println("======================");
         System.out.println("姓名：" + two.getName() + " 年龄：" + two.getAge());
 
     }
 }

1.3常用API第一部分

概述

API，应用程序编程接口，Java API是一本程序员的字典，是JDK提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用，所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用。

1.3.1 Scanner类

什么是scanner类：一个可以解析基本类型和字符串的简单文本扫描器

引用类型的一般使用步骤

 package cn.study.day30.demo04;
 
 import java.util.Scanner; // 导包
 
 /*
     引用类型的一般使用步骤
 
 1、导包
 import 包路径.类名称;
 如果需要使用的目标类，和当下类位于同一个包下，则可以省略导包语句不写
 只有java.lang包下的内容不需要导包，其他的包都需要import语句
 
 2、创建
 类名称 对象名 = new 类名称();
 
 3、使用
 对象名.成员方法名()
 获取键盘输入的一个int数字，int num = sc.nextInt();
 获取键盘输入的一个字符串，String str = sc.next();
 */
 public class Demo04Scanner {
     public static void main(String[] args) {
         // 创建
         // System.in代表从键盘进行输入
         Scanner sc = new Scanner(System.in);
         System.out.println("输入的数字:" + sc.nextInt());
         System.out.println("获取的字符串：" + sc.next());
 
     }
 }

1.3.2 匿名对象

没有名字的对象，叫做匿名对象

注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个对象

 new Student().name = "大方";
 new Student().showName(); // 我叫，null
 // 只输入一次
 int num = new Scanner(System.in).nextInt();

1.3.3 Random类

 package cn.study.day30.demo05;
 
 import java.util.Random;
 
 /*
 1.导包
 import java.util.Random;
 2.创建
 Random r = new Random();
 3、使用
 获取一个随机的int数字（范围是int所有范围，包括正负）:int num = r.nextInt();
 获取一个随机的int数字（参数代表了范围，左闭右开区间）:int num = r.nextInt(3);
 实际上代表的含义是：【0,3）。
 */
 public class Demo05Random {
     public static void main(String[] args) {
         Random r = new Random();
         for (int i = 0; i < 100; i++) {
             System.out.println("第"+ i + "个随机数是：" + r.nextInt(10));
         }
     }
 }

 用代码实现猜数字小游戏
 package cn.study.day30.demo05;
 
 import java.util.Random;
 import java.util.Scanner;
 
 public class Demo05Guess {
     public static void main(String[] args) {
         Random r = new Random();
         int randomNum = r.nextInt(100) + 1;
         Scanner sc = new Scanner(System.in);
 
         while (true) {
             System.out.println("请输入你猜的数字");
             int guessNum = sc.nextInt();
             if (randomNum > guessNum) {
                 System.out.println("猜的小了");
             } else if (randomNum < guessNum) {
                 System.out.println("猜的大了");
             } else {
                 System.out.println("恭喜你猜中了！！！");
                 break;
             }
         }
     }
 }

1.3.4 ArrayList集合

 package cn.study.day30.demo06;
 /*
 题目：
 定义一个数组，用来存储3个Person对象
 
 缺点：一旦创建，程序运行期间，数组的长度不能改变
 */
 public class Demo06Array {
     public static void main(String[] args) {
         Person[] array = new Person[3];
         Person one = new Person("工藤新一", 21);
         Person two = new Person("毛利兰", 20);
         Person three = new Person("毛利小五郎", 37);
 
         array[0] = one;
         array[1] = two;
         array[2] = three;
 
         for (int i = 0; i < array.length; i++) {
             System.out.println("姓名：" + array[i].getName() + " 年龄：" + array[i].getAge());
         }
 
     }
 }

 package cn.study.day30.demo06;
 
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 /*
 对于ArrayList来说，有一个尖括号<E>代表泛型
 泛型：就是装在集合当中的所有元素，全都是统一的类型
 注意：泛型只能是引用类型，不能是基本类型
 注意事项：对于ArrayList集合来说，直接打印得到的不是地址值，而是内容
 如果内容为空，得到的是空的中括号：[]
 */
 public class Demo06ArrayList {
     public static void main(String[] args) {
         // 创建了一个ArrayList集合，集合的名称为list，里面装的全都是String类型的数据
         // 备注：从JDK1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写
         ArrayList<String> list = new ArrayList<>();
         list.add("工藤新一");
         list.add("毛利兰");
         list.add("毛利小五郎"); // [工藤新一, 毛利兰, 毛利小五郎]
         System.out.println(list);
     }
 }

 package cn.study.day31.demo01;
 
 import java.util.ArrayList;
 
 /*
 ArrayList当中的常用方法有：
 
 public boolean add(E e); 向集合当中添加元素，参数的类型和泛型一致
 // 对于ArrayList集合来说，add添加的动作一定是成功的，所以返回值可用可不用
 但是对于其他的集合来说（今后学习），add添加动作不一定成功
 public E get(int index); 从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素
 public E remove(int index); 从集合当中删除元素，参数是索引编号，返回值就是被删除的元素
 public int size(); 获取集合的尺寸长度，返回值是集合中包含的元素个数
 */
 public class Demo01ArrayListMethod {
     public static void main(String[] args) {
         ArrayList<String> list = new ArrayList<>();
         System.out.println(list);
         // 向集合当中添加元素 add
         boolean success = list.add("毛利兰"); // add是有返回值的
         System.out.println(list); // 毛利兰
         System.out.println("添加的动作是否成功：" + success); // true
         list.add("工藤新一");
         list.add("柯南");
         list.add("毛利小五郎");
         System.out.println(list);
         System.out.println("=========================");
         System.out.println(list.get(0)); // 毛利兰
         System.out.println("=========================");
         System.out.println("被删除的人是：" + list.remove(1)); // 被删除的人是：工藤新一
         System.out.println(list); // [毛利兰, 柯南, 毛利小五郎]
         System.out.println("=========================");
         System.out.println("集合的长度为：" + list.size()); // 3
         // 遍历集合
         for (int i = 0; i < list.size(); i++) {
             System.out.println(list.get(i));
         }
     }
 }

 package cn.study.day31.demo01;
 
 import java.util.ArrayList;
 
 /*
 如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的包装类
 
 基本类型    包装类（引用类型，包装类都位于java.lang包下）
 byte    Byte
 short   Short
 int     Integer     【特殊】
 long    Long
 float   Float
 double  Double
 char    Character   【特殊】
 boolean Boolean
 
 从JDK1.5开始，支持自动装箱，自动拆箱
 自动装箱：基本类型 --> 包装类型
 自动拆箱：包装类型 --> 基本类型
 * */
 public class Demo01ArrayListBasic {
     public static void main(String[] args) {
 //        ArrayList<String> list = new ArrayList<>();
         // 错误写法，泛型只能是引用类型，不能是基本类型
 //        ArrayList<int> one = new ArrayList<>();
         ArrayList<Integer> list = new ArrayList<>();
         list.add(100);
         list.add(200);
         list.add(400);
         System.out.println(list.get(2));
         list.remove(1);
         System.out.println(list.size());
     }
 }

 package cn.study.day31.demo01;
 
 import java.util.ArrayList;
 import java.util.Random;
 
 /*
 生成6个1-33之间的随机整数，添加到集合，并遍历集合
 
 * */
 public class Demo01ArrayListRandom {
     public static void main(String[] args) {
         Random r = new Random();
         ArrayList<Integer> list = new ArrayList<>();
         for (int i = 0; i < 6; i++) {
             list.add(r.nextInt(33)+1);
         }
         for (int j = 0; j < list.size(); j++) {
             System.out.println(list.get(j));
         }
     }
 }

 package cn.study.day31.demo01;
 
 import java.util.ArrayList;
 
 /*
 自定义4个学生对象，添加到集合，并遍历
 
 */
 public class Demo01ArrayListStudent {
     public static void main(String[] args) {
         Student one = new Student("柯南", 19);
         Student two = new Student("步美", 9);
         Student three = new Student("光彦", 9);
         Student four = new Student("元太", 9);
         ArrayList<Student> list = new ArrayList<>();
         list.add(one);
         list.add(two);
         list.add(three);
         list.add(four);
         for (int i = 0; i < list.size(); i++) {
             System.out.println("名字：" + list.get(i).getName() + " 年龄：" + list.get(i).getAge());
         }
         /*  名字：柯南 年龄：19
             名字：步美 年龄：9
             名字：光彦 年龄：9
             名字：元太 年龄：9*/
     }
 }

 package cn.study.day31.demo01;
 
 import java.util.ArrayList;
 
 /*
 题目：
 定义以指定格式打印集合的方法（ArrayList类型作为参数），使用{}扩起集合，使用@分割每个元素
 格式参照 {元素@元素@元素}。
 */
 public class Demo01ArrayListPrint {
     public static void main(String[] args) {
         ArrayList<String> list = new ArrayList<>();
         list.add("柯南");
         list.add("步美");
         list.add("光彦");
         list.add("元太");
         System.out.println(list); //[柯南, 步美, 光彦, 元太]
         System.out.println("================");
         printArrayList(list); // {柯南@步美@光彦@元太}
     }
 
     public static void printArrayList(ArrayList<String> list) {
         System.out.print("{");
         for (int i = 0; i < list.size(); i++) {
             if ( i == list.size() - 1 ){
                 System.out.print(list.get(i)+"}");
             }else{
                 System.out.print(list.get(i) + "@");
             }
         }
     }
 }

 package cn.study.day31.demo01;
 
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.Random;
 
 /*
 题目：
 用一个大集合存入20个随机数，然后筛选其中的偶数放入小集合当中
 要求使用自定义的方法实现筛选
 
 * */
 public class Demo01ArrayListReturn {
     public static void main(String[] args) {
         ArrayList<Integer> list = new ArrayList<>();
         Random r = new Random();
         for (int i = 0; i < 20; i++) {
             list.add(r.nextInt(100) + 1);
         }
         System.out.println(list);
         System.out.println("===================");
         System.out.println(returnArrayList(list));
     }
 
     public static ArrayList<Integer> returnArrayList(ArrayList<Integer> list) {
         ArrayList<Integer> li = new ArrayList<>();
         for (int i = 0; i < list.size(); i++) {
             if (list.get(i) % 2 == 0){
                 li.add(list.get(i));
             }
         }
         return li;
     }
 }

1.3.5 String类

 package cn.study.day31.demo02;
 
 /*
 java.lang.String类代表字符串
 字符串的特点：
 1、字符串是常量，字符串的内容永不可变【重点】
 2、正是因为字符串不可改变，所以字符串是可以共享使用的
 3、字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组
 
 创建字符串的常见3+1种方式
 三种构造方法：
 public String(); 创建一个空白字符，不含有任何内容
 public String(char[] array); 根据字符数组的内容，来创建对应的字符串
 public String(byte[] array); 根据字节数组的内容，来创建对应的字符串
 一种直接创建：
 String str = "Hello"; // 右边直接用双引号哦
 注意：直接写上双引号，就是字符串对象。【重点】
 * */
 public class Demo02String {
     public static void main(String[] args) {
         // 空参构造
         String str1 = new String();
         System.out.println("第一个字符串： " + str1);
         System.out.println("=====================");
         // char型数组构造
         char[] charArray = {'A','B','D'};
         String str2 = new String(charArray);
         System.out.println("第二个字符串： " + str2);
         System.out.println("=====================");
         // byte型数组构造
         byte[] byteArray = {97, 98, 100};
         String str3 = new String(byteArray);
         System.out.println("第三个字符串：" + str3);
         System.out.println("=====================");
         //直接创建
         String str4 = "HelloWorld";
         System.out.println("第四个字符串：" + str4);
 
     }
 }

 package cn.study.day31.demo02;
 /*
 字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池当中。只有双引号中的字符串才在常量池里
 
 对于基本类型来说， == 是进行数值的比较
 对于引用类型来说， == 是进行地址的比较
 * */
 public class Demo02StringPool {
     public static void main(String[] args) {
         String str1 = "abc";
         String str2 = "abc";
         char[] charArray = {'a', 'b', 'c'};
         String str3 = new String(charArray);
         System.out.println(str1 == str2); // true
         System.out.println(str2 == str3); // false
         System.out.println(str1 == str3); // false
 
     }
 }

 package cn.study.day31.demo02;
 
 /*
 ==是进行对象的地址值比较，如果确实需要字符串的内容的比较，可以使用两个方法
 public boolean equals(Object obj); 参数可以是任何对象【只有参数是一个字符串并且内容完全相同才会输出true，否则false
 注意事项：
 1、任何对象都能使用Object进行接收
 2、equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样
 3、如果比较双方一个常量一个变量，推荐把常量字符串写在前面
 推荐 "abc".equals(str1)  不推荐： str.equals("abc")
 .之前的如果是null，则会发生空指针异常
 
 public boolean equalsIgnoreCase(String str); 忽略大小写，进行内容的比较
 * */
 public class Demo02StringEquals {
     public static void main(String[] args) {
         String str1 = "abc";
         String str2 = "abc";
         char[] charArray = {'a', 'b', 'c'};
         String str3 = new String(charArray);
         System.out.println(str1.equals(str2));  // true
         System.out.println(str1.equals(str3));  // true
         System.out.println(str3.equals(str2));  // true
         System.out.println(str1.equals("abc")); // true
         System.out.println("abc".equals(str3)); // true
 
         String str = null;
 //        System.out.println("abc".equals(str)); // 推荐  false
 //        System.out.println(str.equals("abc")); // 不推荐 会出现空指针异常
 
         String strA = "java";
         String strB = "Java";
         System.out.println(strA.equals(strB)); //false
         System.out.println(strA.equalsIgnoreCase(strB)); // true 
 
     }
 }

 package cn.study.day31.demo02;
 /*
 String当中与获取相关的常用方法有：
 
 public int length(); 获取当前字符串当中含有的字符个数，拿到字符串长度
 public String concat(String str);将当前字符串和参数字符串拼接成为返回值新的字符串
 public char charAt(int index));获取指定索引位置的单个字符。
 public int indexOf(String str); 查找参数字符串在本字符串当中首次出现的索引位置，如果没有则返回-1值
 
 * */
 public class Demo02StringGet {
     public static void main(String[] args) {
         System.out.println("字符串的长度为：" + "sdajflaksjdflasjdfklasdjflasjdflkas".length()); // 35
         String str1 = "Hello";
         String str2 = "World";
         String str3 = str1.concat(str2);
         System.out.println(str1); // Hello
         System.out.println(str2); // World
         System.out.println(str3); // HelloWorld
 
         char ch = str1.charAt(1);
         System.out.println("在一号位置的索引字符是：" + ch); // e
         System.out.println("================");
         String original = "HelloWorld";
         System.out.println(original.indexOf("el"));  // 1
     }
 }

 package cn.study.day31.demo02;
 
 import com.sun.security.jgss.GSSUtil;
 
 /*
 字符串的截取方法：
 
 public String substring(int index);截取从参数位置一直到字符串末尾，返回新字符串
 public String substring(int begin, int end); 截取从begin开始，一直到end结束，中间的字符串
 注意事项：
 [begin，end）
 * */
 public class Demo02Substrin {
     public static void main(String[] args) {
         String str = "HelloWorld";
         System.out.println(str.substring(5)); // World
         System.out.println(str.substring(1, 5)); // ello
         System.out.println(str.substring(3,8)); // loWor
 
         // 字符串内容没有改变
         // 下面有两个字符串
         // 而strA中存的是地址值
         String strA = "Hello";
         System.out.println(strA);
         strA = "java";
         System.out.println(strA);
     }
 }

 package cn.study.day01.demo01;
 /*
 String当中与转换相关的常用方法有：
 
 public char[] toCharArray();  将当前字符串拆分成为字符数组作为返回值
 public byte[] getBytes();     获得当前字符串底层的字节数组
 public String replace(CharSequence oldString, CharSequence newString);
 将所有出现的老字符串替换成为新的字符串，返回替换之后的新字符串
 
 * */
 public class Demo01StringConvert {
     public static void main(String[] args) {
         char[] chars = "Hello".toCharArray();
         System.out.println(chars[1]);  // e
         System.out.println(chars.length);   // 5
         System.out.println("================");
         byte[] bytes = "Hello".getBytes();
         for (int i = 0; i < bytes.length; i++) {
             System.out.println(bytes[i]);
         }
         System.out.println("==================");
         String str1 = "How do you do?";
         String str2 = str1.replace('o','#');
         System.out.println(str1); // How do you do?
         System.out.println(str2); // H#w d# y#u d#?
 
     }
 }

 package cn.study.day01.demo01;
 
 /*
 题目：
 定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串，格式参照如下：[word1#word2#word3]
 
 * */
 public class Demo01StringPractise {
     public static void main(String[] args) {
         int[] array = {1, 2, 3};
         System.out.println(fromarryToString(array)); // [word1#word2#word3]
     }
 
     public static String fromarryToString(int[] array) {
         String str = "[";
         for (int i = 0; i < array.length; i++) {
             if (i == array.length - 1) {
                 str += "word" + array[i] + "]";
             } else {
                 str += "word" + array[i] + "#";
             }
         }
         return str;
     }
 }

 package cn.study.day01.demo01;
 
 import java.util.Scanner;
 
 /*
 题目：
 键盘输入一个字符串，并且统计其中各种字符出现的次数
 种类有：大写字母，小写字母，数字，其他
 
 分析：
 键盘输入 Scanner
 字符串 String str = sc.next();
 定义四个变量，出现次数
 对字符检查，toCharArray()
 遍历
 打印
 * */
 public class Demo01StringCount {
     public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入一个字符串：");
         String str = sc.next();
         char[] chars = str.toCharArray();
         int countUpper = 0;
         int countLower = 0;
         int countNumber = 0;
         int countOther = 0;
         for (int i = 0; i < chars.length; i++) {
             if (chars[i] >= 'A' && chars[i] <= 'Z') {
                 countUpper++;
             } else if (chars[i] >= 'a' && chars[i] <= 'z') {
                 countLower++;
             } else if (chars[i] >= '0' && chars[i] <= '9') {
                 countNumber++;
             }else{
                 countOther++;
             }
         }
         System.out.println("大写字母有："+countUpper);
         System.out.println("小写字母有："+countLower);
         System.out.println("数字有："+countNumber);
         System.out.println("其他字符有："+countOther);
     }
 }

1.3.6 static静态

 package cn.study.day02.demo01;
 
 public class Student {
     private int id;
     private String name;
     private int age;
     static String room; // 所在教室
     private static int idCounter; // 学号计数器
 
     public Student() {
         this.id = ++idCounter;
     }
 
     public Student(String name, int age) {
         this.name = name;
         this.age = age;
         this.id = ++idCounter;
     }
 
     public int getId() {
         return id;
     }
 
     public void setId(int id) {
         this.id = id;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getAge() {
         return age;
     }
 
     public void setAge(int age) {
         this.age = age;
     }
 }
 
 package cn.study.day02.demo01;
 
 /*
 如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于对象所在的类，多个对象共享同一份数据
 * */
 public class Demo01StaticField {
     public static void main(String[] args) {
         Student one = new Student("毛利兰", 19);
         Student two = new Student("名侦探", 9);
         one.room = "101教室";
         System.out.println(one.room + "学号" + one.getId()); // 101教室 1
         System.out.println(two.room + "学号" + two.getId()); // 101教室 2
     }
 }

 package cn.study.day02.demo01;
 
 public class Myclass {
     public void method() {
         System.out.println("这是一个普通的成员方法");
     }
 
     public static void methodStatic() {
         System.out.println("这是一个静态方法");
     }
 }
 
 package cn.study.day02.demo01;
 /*
 一旦使用static修饰成员方法，就成为了静态方法
 静态方法是属于类的
 
 如果没有static关键字，必须创建一个对象才能使用
 对于静态方法来说，可以通过对象名进行调用，也可以直接用类名称进行调用
 
 无论是成员变量，还是成员方法，有了static关键字，都推荐使用类名称进行调用
 静态变量：类名称.静态变量
 静态方法：类名称.静态方法()
 
 注意事项：
 1、静态不能直接访问非静态
 原因：在内存当中，是【先】有的静态，【后】有的非静态
 2、静态方法中不能用this
 原因：this代表当前对象，通过谁调用的方法，谁就是当前对象
 * */
 public class Demo01StaticMethod {
     public static void main(String[] args) {
         Myclass obj = new Myclass();
         obj.method(); // 这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
         Myclass.methodStatic();
     }
 }

 package cn.study.day02.demo01;
 
 /*
 静态代码块的格式是：
 
 public class 类名称{
     static{
         静态代码块的内容
     }
 }
 特点：当第一次用到本类时，静态代码块执行唯一的一次
 静态内容总是优先于非静态，
 
 静态代码块的典型用途：
 用来一次性的对静态成员变量进行赋值
 * */
 public class Person {
     static{
         System.out.println("静态代码块执行！");
     }
 
     public Person() {
         System.out.println("构造方法执行！");
     }
 }

1.3.7 Array工具类

 package cn.study.day02.demo02;
 
 import java.util.Arrays;
 
 /*
 java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作
 
 public static String toString(数组):将参数数组变成字符串（按照默认格式[元素1，元素2，元素3……]）
 public static void sort(数组)：按照默认升序对数组进行排序
 
 注意事项：
 1、如果是数字，则升序
 2、如果是字符串，sort默认按照字母升序
 3、如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持（今后学习）
 * */
 public class Demo02Arrays {
     public static void main(String[] args) {
         int[] intArray = {10, 20, 40};
         System.out.println(Arrays.toString(intArray)); // [10, 20, 40]
         int[] array1 = {1, 2, 6, 565, 65, 65, 65, 6, 5, 65, 6, 5, 65, 65, 6, 5, 65, 65, 6, 5, 68, 97, 79, 797, 98, 78, 7, 87, 9};
         Arrays.sort(array1);
         System.out.println(Arrays.toString(array1));
     }
 }

 package cn.study.day02.demo02;
 
 import java.util.Arrays;
 
 /*
 题目：
 请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印
 
 * */
 public class Demo02ArraysPractise {
     public static void main(String[] args) {
         String str = "safalskdfjasldFAJSLKDFJASLDFJ";
         char[] charArray = str.toCharArray();
         Arrays.sort(charArray);
         for (int i = charArray.length - 1; i >= 0; i--) {
             System.out.println(charArray[i]);
         }
     }
 }

1.3.8 Math类

 package cn.study.day02.demo02;
 
 /*
 java.util.Math是数学相关的工具类，里面提供了大量的静态方法，完成与数学相关的操作
 public static double abs(double num) 绝对值
 public static double ceil(double num) 向上取整
 public static double floor(double num) 向下取整
 public static double round(double num) 四舍五入
 
 Math.PI代表近似的圆周率常量（double）
 * */
 public class Demo02Math {
     public static void main(String[] args) {
         System.out.println(Math.abs(-3.14));
         System.out.println(Math.ceil(21/10)); // 2.0
         System.out.println(Math.ceil(2.1));   // 3.0
         System.out.println(Math.floor(21/10));// 2.0
         System.out.println(Math.floor(2.1));  // 2.0
         System.out.println(Math.round(3.14)); // 3
     }
 }

 package cn.study.day02.demo02;
 
 /*
 题目：
 计算在-10.8到5.9之间，绝对值大于6，或者小于2.1的整数有多少个
 
 * */
 public class Demo02MathPractise {
     public static void main(String[] args) {
         int min = (int) Math.ceil(-10.8);
         System.out.println(min);
         int max = (int) Math.floor(5.9);
         System.out.println(max);
         int num = 0;
         for (int i = min; i <= max; i++) {
             if (Math.abs(i) < 2.1 || Math.abs(i) > 6) {
                 System.out.print(i+" ");
                 num++;
             }
         }
         System.out.println("这样的数有：" + num);
     }
 }