本文是一篇全面的Java学习指南，涵盖了从Java环境配置到数据类型、运算符、数组、类与对象的深入讲解，还涉及API文档、异常处理、集合框架等内容，旨在帮助读者快速掌握Java编程基础。
如何快速学习技术或知识
1、需求
-
工作需求
-
跳槽对方需求
-
技术控
2、能否使用传统技术解决
-
能解决但是不完美
-
解决不了
3、引出我们学习的新技术和知识点
4、学习新技术或者知识点的基本原理和基本语法
5、快速入门（基本程序，CRUD）
6、开始研究技术的注意事项，使用细节使用规范如何优化 注：优化无止境
一、Java简介
JDK JRE JVM 的关系
JDK = JRE + java开发工具
JRE = JVM + 核心类库
JDK Java Development Kit 针对 Java 开发员的软件开发工具包 没有JDK就无法编译程序
JRE Java Runtime Environment java运行环境 没有JRE程序无法运行 内置了 Java虚拟机
配置环境变量的作用
1、为了在Dos的任意目录可以使用java，javac命令
2、先配置JAVA_HOME 指向JDK的安装主目录
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6FXgebFL-1666510554270)(./images/JAVA_HOME.png)]
3、在path环境变量中增加%JAVA_HOME%bin %代表引用
jdk 和jre 都需要添加进去
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uDCTL7Rc-1666510554271)(./images/path.png)]
4、编写Java的源代码 javac __ 编译 java __ 运行 运行时不用加class后缀
Java内存的结构分析
-
栈：一般存放基本数据类型（局部变量）
-
堆：存放对象（Cat cat ,数组等）
-
方法区：常量池（常量，比如字符串），类加载信息
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-efW6zoiE-1666510554272)(./images/oopcreate.png)]
编译第一个Java程序
新建一个hello.java文件输入代码
public class hello {
public static void main (String [] args){
System.out.println("Hello world");
}
}
类名必须与文件名一致
编码可以用Ascll编码
带中文需要更换编码格式 否则可能会报错
javac hello.java编译该程序
java hello运行该程序
反编译
Javap 是jdk 提供的一个命令工具，javap能对给定的class文件提供的字节代码进行反编译 简单来说就是 将 .class -> .java
使用格式
javap
常用 javap -c /-v
-version 版本信息
-v -verbose 输出附加信息
-i 输出行号和本地变量表
-public 仅显示公共类和成员
-protected 显示受保护成员和上面的
-package 显示程序包和上面的
-p - private 显示所有类和成员
-c 对代码进行反汇编
-s 输出内部类型签名
-sysinfo 显示正在处理的类的信息
…
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7YfZIQqn-1666510554272)(./images/hello.png)]
二、数据类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aU11YXnf-1666510554273)(./images/datatype.png)]
变量：先声明再使用
JAVA中默认为Double
1.基本数据类型
int 4个字节 byte short 2个字节
float 4个字节
double 8个字节
char 2个字节
boolean 1个字节（true/false）
2.引用数据类型
class 类 <---- string 属于类里面的
interface 接口类型
数组[]
Java空与null的区别
1、类型
null表示的是一个对象的值，而不是一个字符串。例如声明一个对象的引用，
String a=null。
“”表示的是一个空字符串，也就是说它的长度为0。例如声明一个字符串
String s=”“。
2、 内存分配
String a=null；表示声明一个字符串对象的引用，但指向为null，也就是说还没有指向任何的内存空间。
String s=”“；表示声明一个字符串类型的引用，其值为“”空字符串，这个s引用指向的是空字符串的内存空间；
3.浮点数
浮点数 = 符号位 + 指数位 + 尾数位
JAVA中默认为Double
例如：
float num1 = 1.1; //错误 1.1 是Double类型 大-->小 需要强制转换
float num2 = 1.1f; //对
float num3 = 3.1415926535F;
//输出结果为3.1415926
double num4 = 8.1 / 3;
double num5 = 2.7;
//输出 num4 = 2.69999999999999997
if(num4 ==num5)
//输出为false
总结 当运算结果进行相等判断时要小心，应是两者差值的绝对值在某个精度
如
if(Math.abs(num5 - num4)<0.000001)
char c1 = 'a';
char c2 = 97;
//输出结果都是 a
'a'--> ascll码 97 --> (10001)B -->存储
char本质是一个整数 输出一个Unicode编码代表对应一个字符
ASCLL码 1个字节表示 0000 0000 一共有128个字符 但可以表示256个 只用了128
UTF - 8 字母 1个字节 汉字三个字节 0000 0000
Unicode 固定大小 字母汉字都是2个字节
4.基本数据类型转换（自动）Auto Convert
char -> int -> long -> float -> double
byte -> short -> int ->long -> float ->double
byte char short 中不发生自动转换 计算时首先转换成int类型
当多种类型转换时 转为最大容量的类型
运算结果自动提升至操作数中最大类型
注意：
三元运算符是一个整体，如果中间有不同类型的数据，会转会最大容量的类型
int a=10;
float = a + 1.1;
//报错 1.1 已经是Double 类型 小不能转大
5.数据强制转换
大–>小 只作用于最近的操作数
int i = (int)(3.5*10 +6 *44)
//结果为44
如不加强转将报错
基本类型数据转String
int i = 10;
i + "";
//即为string
char 与 string 转换时只取第一个
String a = "guofeng";
char b = a.charAt(0);// 选择取第几个
//输出b = g;
String 转其他数据类型
String S1 = "123";
//转int
int num = Integer.parseInt(S1);
Double num1 = Double.parseDouble(S1);
Float num2 = Float.parseFloat(S1);
char num3 = S1.charAt(1);
System.out.println(num);
System.out.println(num3);
System.out.println(num1);
System.out.println(num2);
// 123
// 2
// 123.0
// 123.0
三、运算符
加减乘除主要是除法需要注意
复合赋值运算会进行类型转换
byte b =3;
b += 2;
// 等价 b = (byte)(b+2); b++; b--; 同理
//如写成 b = b + 2;则报错 大转小需强制转换
除法 /
System.out.println(10.0 / 4); // 2.5
Double d = 10 / 4; // 2.0
取余/取模 %
a % b = a - a / b * b
当a 是负数时 a - (int) a / b * b
10 % 3 // 1 a % b = a - a / b * b
-10 % 3 // -1
10 % -3 // 1
// 10-10/（-3）*3 = 10 -9 = 1
-10 % -3 // -1
// -10 -（-10）/（-3）*（-3） = -10-（-3）*（-3） = -10 + 9 = -1
自加自减 ++ –
本质 有一个 temp 变量
i++:
temp = i;
i = i + 1;
i = temp;
++i:
i = i + 1;
temp = i;
i = temp:
自加在前 先运算再赋值
自加在后 赋值后在运算
int i = 1;
i = i++;
print(i)
//输出 i = 1；
int i = 1;
i = ++i;
print(i)
//输出 i = 2
1.关系运算符
== != >= <= > <
运算结果都是Boolean型
逻辑运算符
短路 与 && 或 || 取反 ！
逻辑 与& 或 | 异或 ^
**短路与逻辑 之间的差别：**以 “与”为例子
第一个条件为false， 则第二个条件不会判断（执行）
不管第一个是否为false，第二个条件都会判断（执行）
短路 或|| 第一个为true 第二个不判断
2.进制转换
进制类型
二进制 ob 开头
十进制
八进制 数字0开头
十六进制 Ox
十六进制Ox 3B5C转换成二进制
每一位都是表示4个二进制 2^4
0011 1011 0101 1100
二进制转十进制
取 1 位一组相加
（0011 1011 0101 1100）B
2^13 + 2^12 + 2^11 +2^9 +2^8 + 2^6 + 2^4 +2^3 +2^2
=35534
二进制转八进制
从右往左取3位一组相加
二进制转十六进制
取4位一组相加
3.位运算
计算机中数据存储都是以二进制保存计算 Binary 二进制
一切运算都是以补码的方式来运算
>> 向右位移两位
低位溢出，符号位不变并用符号位补溢出的高位
本质就是 / 2
<< 向左位移两位
符号位不变，低位补零
本质就是 * 2
>>> 无符号右移
**<<<**无符号左移
~ 按位取反
& 按位与
| 按位或
^ 按位异或
//计算下面结果
//int 4 个字节
0000 0000 | 0000 0000 | 0000 0000 | 0000 0000
//下面计算忽略前面3个字节
~ 2
// 0000 0010 先算出补码 正数的补码就是他本身
// 取反操作（它的补码）
// 1111 1101
// 求原码 -1
// 1111 1100
// 0000 0011
//结果为3 但是补码的符号位是1所以最后结果是 -3
2 & 3
//求出补码
//0000 0010 2
//0000 0011 3
//与运算 得补码
//0000 0010
//求原码 正数即是本身
//结果为 2
2 | 3
// 0000 0010
// 0000 0011
// 0000 0011
//结果为3
~ -5
//求补码 -5
//负数的补码是除了符号位外取反 + 1
// 1000 0101
// 1111 1011
//取反操作
// 0000 0100 求原码 正数
//结果 4
-3 ^ 3
// 1000 0011 -3
// 0000 0011 3
//求补码
// 1111 1101
// 0000 0011
// 异或操作
// 1111 1110 求原码
// 1111 1101
// 0000 0010
//结果为 -2
四、API 文档
API application programming interface 应用程序编程接口
可以看到里面的各种包 里面接口 类 异常…
中文在线文档
www.matools.com
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M4fgAucx-1666510554274)(./images/Api.png)]
五、选择
If-else
基本语法
if ( 判断语句){
}else{
}
判断语句必须结果必须是Boolean类型，非真即假
Switch case
switch (表达式)
{
case 常量表达式1： 语句1
case 常量表达式2： 语句2
┇
case 常量表达式n： 语句n
default: 语句n+1
}
六、循环
多重循环例题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iIFS55y2-1666510554275)(./images/xunhuan.png)]
99乘法表
public class Multable{
public static void main (String [] args){
int i,j=1;
for( i = 1;i<10;i++){
for( j = 1;j<10;j++){
if(i==j){
System.out.println(i+" x "+ j +" = "+i*j);
}else if(j<i){
System.out.print(j + " x "+ i +" = "+i*j +"\t");
}
}
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QGFfogPS-1666510554275)(./images/Multable1.png)]
输出镂空菱形
import java.util.Scanner;
public class stars{
public static void main (String [] args){
/*
* * 3个空格 第1行 1个*
*** * * 2个空格 第2行 3个*
***** * * 1个空格 第3行 5个*
******* ---> * * 0个空格 第4行 7个*
***** * * 第5行 5个*
*** * * 第6行 3个*
* * 第7行 1个*
*/
Scanner myscanner = new Scanner(System.in);
System.out.print("输入要打印菱形大小");
int N = myscanner.nextInt();
for(int i = 1;i <= N ;i ++){
//控制行数
for(int j = 1; j<= N - i;j++){
//行数前空格输出
System.out.print(" ");
}
for(int k = 1;k <= 2 * i - 1;k++){
// 每行输出的* 为2n - 1
if(k==1||k==2 * i - 1){
//只输出第一个和最后一个*
System.out.print("*");
}else
System.out.print(" ");
}
System.out.println("");
//打印完一行立刻换行
}
for(int i = N - 1 ; i>0;i--){
//倒过来输出 从最后一行往上打印
for(int j = N - i;j>0;j--){
System.out.print(" ");
}
for(int k = 2 * i - 1;k>0;k--){
if(k==1||k==2 * i - 1){
System.out.print("*");
}else
System.out.print(" ");
}
System.out.println("");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EHnHAive-1666510554276)(./images/stars.png)]
七、数组
数组可以存放多个同一类型的数据。数组也是也一种数据类型，是引用类型。即：数组就是一组数据
数组的使用
方式1动态初始化
数组的定义：
//数据类型 数组名 [] = new 数据类型 [大小]
int a [] = new int [5];
//定义了一个数组 名字叫a 存放5个int
数组的引用
//数组名[下标/索引] 例如要使用a 数组的第三个数
a[2]
方式2 动态初始化
先声明再创建数组
// 数据类型 数组名 [];
int a [];
// 数组名 = new 数据类型[大小];
a= new int [10];
方式3 静态初始化
初始化数组
// 适用于已知大小的数组
// 数据类型 数组名 [] ={元素值,元素值...}
int a [] = {
1,2,3,4,5}
//相当于
int a[] = new a[5];
a[0]=1;a[1]=2;a[2]=3;a[3]=4;a[4]=5;
1.注意细节
- 数组是多个相同类型的数据的组合，实现对这些数据的统一管理
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
- 数组中的元素可以是任意数据类型，包括基本类型和引用类型，但是不能混用
- 数组创建后，如果没有赋值，有默认值
- int short byte long 0
- float double 0.0
- char \u0000 \u 代表16进制
- Boolean false
- String null
- 使用数组的步骤
- 声明数组并开辟空间
- 给数组各个元素赋值
- 使用数组
- 数组的下标是从0开始
- 数组的下标必须在指定范围使用，否则越界异常，比如 int [] array = new int [5];则有效下标为0~4
- 数组属于引用类型，数组型数据是对象
例题
例题1：
/*
创建一个char类型数组，分别放置'A'-'Z',
使用for循环所有元素并打印出来。
提示：char 类型数据运算 'A' + 1 = 'B'
*/
char [] chars = new char[26];
for ( int i = 1; i< chars.length;i++){
//遍历数组所有值
//chars[i] = (char)('A') +(char)(i);
//这样写是错误的 强转为char再计算 但是char类型在进行计算时是会自动转换为int类型来计算
//int 再转为chars[i] 属于小转大 报错
chars[i] = (char)('A' + i);
}
}
例题2：
/*
求出一个数组int[]的最大值{4，-1，9，10，23}，并得到对应的下标
*/
int a[] = {
4,-1,9,10,23,9};
max = a[0]; //假定你是最大值
int maxindex = 0;
for(int i = 1; i< a.length;i++){
//遍历数组 如果你比他大 不做改变 如果比他小 更换最大值
if(max < a[i]){
max = a[i];
maxindex = i;
}
}
System.out.print("最大值是"+max+"下标为"+maxindex);
2.数组赋值机制
-
基本数据类型赋值，这个值解释具体的数据，而且相互不影响 值拷贝
- int n1 = 2;
- int n2 = n1;
-
数组在默认情况下是引用传递，赋的值是地址 引用拷贝
int arr1[]={ 1,2,3}; int arr2[] = arr1; arr2[0] = 10; for(int i =0; i<arr1.length;i++){ System.out.print(arr1[i] + " "); //输出结果为 10 2 3 }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UP5Ye8ve-1666510554277)(./images/array1.png)]
3.数组拷贝
将int [] arr1 = {10,20,30};拷贝到arr2数组，要求数据空间是独立的
int arr1[] = {
10,20,30};
int arr2[] = new int arr2[arr1.length];
//给arr2开辟哟个新的空间
//所以两个独立了
for (int i =0 ;i< arr1.length;i++){
arr2[i] = arr1[i];
}
4.数组添加
要求实现动态的给数组添加元素效果，实现对数组扩容。
-
原始数组使用静态分配 int array[] = {1,2,3}
-
添加的元素，直接放在数组的最后 array = {1,2,3,4}
-
用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？ y/n
使用do-while 会更简单 一点
import java.util.Scanner;
public class Array03{
public static void main (String [] args){
/*
1. 原始数组使用静态分配 int array[] = {1,2,3}
2. 添加的元素，直接放在数组的最后 array = {1,2,3,4}
3. 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？ y/n
*/
int arr1 [] = {1, 2, 3};
int arr2 [];
char flag = 'y'; //初始化循环标志
Scanner input = new Scanner(System.in);
while('y'==flag){
for(int j = 0 ; j < arr1.length; j++)
System.out.print(arr1[j]+" "); //输出当前数组
System.out.println("是否添加数组 y/n");
flag = input.next().charAt(0);
if ('n'==flag) { //判断是否添加数组
break;
}else{
System.out.println("输入你要添加的元素");
int j = input.nextInt(); //得到你要添加的元素
arr2 = new int [(arr1.length+1)]; //初始化数组 长度为arr1 + 1
for(int i=0;i<arr1.length;i++){
//遍历数组拷贝到arr2
arr2[i] = arr1[i];
}
arr2[arr2.length-1] = j;
//将添加的元素加入数组
arr1 = arr2; //将arr1 指向 添加完之后的arr2
}
System.out.println("添加成功");
}
for(int j = 0 ; j < arr1 .length; j++)
System.out.print(arr1[j]+" "); //输出当前数组
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pJX1GhIX-1666510554278)(./images/array2.png)]
### 5.冒泡排序
BubbleSort
~~~java
import java.util.Scanner;
public class bubbleSort{
public static void main (String [] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入你要排序的个数");
int k = input.nextInt();
int arr0[] = new int [k];
for(int i = 0;i<k;i++){
System.out.println("请输入你要排序的整数");
int j = input.nextInt();
arr0[i] = j;
}
System.out.println("当前数组");
for(int m = 0;m < arr0.length;m++)
System.out.print(arr0[m]+" ");
System.out.println("");
//冒泡排序
//int arr1[] = {15,65,31,42,89,4};
for(int j = 0;j<arr0.length-1;j++)
//要进行这种循环的次数是 个数 - 1
for(int i = 0;i<arr0.length-1-j;i++){
//每进行一次循环 会把一个最大的数放到最后
if (arr0[i]>arr0[i+1]){
int temp;
temp = arr0[i];
arr0[i] = arr0[i+1];
arr0[i+1] = temp;
}
}
System.out.println("排序后的数组");
for(int m = 0;m < arr0.length;m++)
System.out.print(arr0[m]+" ");
}
}
优化：如果给定的数组是有序的，不需要排序 可以提前结束
思路 添加一个count 计数，每次排序结束后+1 判断如果和之前的一样 就退出循环
二维数组
- 使用方法一语法：类型 [] [] 数组名 = new 类型 [大小] [大小]
- 例如 int a [] [] = new int [2] [3];
- 内存存储 存的是一个地址 （引用存储）
使用方法二：
先声明再使用
int array [] [] ;
array = new int [2] [3];
列数不确定性
//案例 定义一个二位数组 要求输出
public class doubleArray{
public static void main (String [] args){
// 1
// 2 2
// 3 3 3
int array [][] = new int [3][];
for(int i = 0; i< array.length;i++){
//遍历 数组 的所有元素
array[i] = new int [i+1]; // 开辟空间
for(int j = 0;j < array[i].length;j++){
//给开辟的空间赋值
array[i][j] = i+1;
}
}
for(int i = 0;i<array.length;i++){
//输出二维数组
for(int j = 0; j< array[i].length;j++){
System.out.print(array[i][j]+" ");
}
System.out.print("\n");
}
}
}
使用方法三：
静态定义：
int array [3] [3] = { {1}, {2，2},{3，3，3} };
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IBZdH0Ys-1666510554278)(./images/er_array.png)]
int array [] [] = { {},{},{},{}}
原来一维数组的每个元素是一堆数组 构成了二维数组
如果需要得到每个一维数组的值还需要再次遍历
如果我们要访问第 (i+1)个数组的第（j+1）个值 array[i] [j]
下标都是从零开始
//输出
// 0 0 0
// 1 0 1
// 0 1 0
int array [] [] = {
{
0,0,0},{
1,0,1},{
0,1,0} };
for(int i = 0; i< array.length;i++){
//遍历二维数组的每个元素
//每个元素也是一个数组
for(int j = 0; j<array[i].length;j++){
//得到二维数组对应的每个元素（一维数组）的长度
System.out.print(array[i][j] + "\t");
}
System.out.println();//换行
}
1.打印杨辉三角
//使用二维数组打印10行杨辉三角
// 1
// 1 1
// 1 2 1
// 1 3 3 1
// 1 4 6 4 1
// 1 5 10 10 5 1
// ......
//使用二维数组打印10行杨辉三角
// 1 5个空格 每行元素 1
// 1 1 4 从第三行开始 对于非第一个和最后一个元素的值
// 1 2 1 3 array[i][j] = array[i-1][j-1] + array[i-1][j]
// 1 3 3 1 2
// 1 4 6 4 1 1
// 1 5 10 10 5 1 0
// ......
public class doubleArray1{
public static void main (String [] args){
// 先死后活
int array [] [] = new int [10][];
for(int i =0;i<array.length; i++){
//打印行数
array[i] = new int [i+1];
for(int j =0; j < i + 1;j++){
//每行个数 = 行数
if(j == 0 || j ==i){
//判断是否是第一个和最后一个
array[i][j] = 1;
}else{
array[i][j] = array[i-1][j-1] + array[i-1][j];
}
}
}
for(int i = 0;i<array.length;i++){
for(int j = 0 ;j<array[i].length;j++){
// if(j == 0){ // 排版一下
// for(int k= array.length - array[i].length;k>0;k--)
// System.out.print(" ");
// }
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}
}
例题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C8zTA2HM-1666510554279)(./images/arraywork1.png)]
第一题
BD
第二题
blue
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4sjTKipk-1666510554279)(./images/arraywork2.png)]
1
3
5
7
第四题
import java.util.Scanner;
public class work1{
public static void main (String [] args){
//要求：
//已知一个升序数组，要求插入一个元素，该数组依旧是升序，比如[10,12,45,90]
//添加23后，数组为[10,12,23,45,90]
Scanner input = new Scanner(System.in);
int []arr1={
10,12,45,90};
System.out.println("输入你要添加的数字");
int num = input.nextInt();
int flag = -1;
int [] arr2 = new int [arr1.length + 1];
for(int i = 0;i<arr1.length;i++){
//遍历原来数组
if (num <= arr1[i]){
//如果当前数字比输入的大
flag = i;
break;
//找到要插入的位置
}
}
System.out.println(flag);
if(flag == -1){
//如果没有找到比插入的数字大的 则加到最后
for(int i =0;i<arr1.length;i++)
arr2[i]=arr1[i];
arr2[4] = num;
}else{
for(int i =0;i<arr2.length;i++){
if(i ==flag){
arr2[i]=num;
}else if(i>flag){
arr2[i] = arr1[i-1];
}else
arr2[i] = arr1[i];
}
}
for(int i=0;i<arr2.length;i++){
System.out.print(arr2[i]+" ");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Mq4PgkFw-1666510554279)(./images/arraywork3.png)]
第五题
public class work2{
public static void main (String [] args){
//随机生成10个整数（1-100） 并保存到数组，并倒序打印
//求出其最大值最小值的下标和平均值
//并查找里面是否有8
int []arr1 = new int [10];
for(int i = 0;i<10;i++){
arr1[i] = (int)((Math.random()*100)+1);
}
double sum = 0;
for(int i =0;i<10;i++){
sum+=arr1[i];
System.out.print(arr1[i]+" ");
if(arr1[i]==8){
System.out.println("有8");
}
}
System.out.println();
System.out.println("平均值为"+sum/10);
System.out.println("排序之后的数组");
for(int i= 0;i<9;i++){
//遍历数组
for(int j =0; j < 9-i;j++){
//进行比较
if(arr1[j]<arr1[j+1]){
int temp = arr1[j];
arr1[j] =arr1[j+1];
arr1[j+1] = temp;
}
}
}
System.out.println();
for(int i =0;i<10;i++){
System.out.print(arr1[i]+" ");
}
}
}
八、类与对象
1.引入问题：
张老太养了两只猫：一只小白 今年三岁 白色
一只小花 今年五岁 花色
请编写一个程序，当用户输入小猫的名字时，
就显示该猫的信息，输入小猫名字错误则提示张老太没有这只猫
//单独变量来解决 ==> 不利于数据管理 （把猫的信息进行了拆解）
String cat1Name = "";
int cat1Age = "";
String cat1Color = "";
String cat2Name = "";
int cat2Age = "";
String cat2Color = "";
//数组==> 1. 数据类型体现不出 2.只能通过下标获取信息
//造成变量名和内容的对应关系不明确3.不能体现猫的行为
String [] cat1 = {
"", "", "",};
String [] cat2 = {
"", "", "",};
引用新的技术：OOP 面向对象
一个程序就是一个世界，有很多事务（对象[属性，行为/方法]）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RNHqx2dy-1666510554280)(./images/oop.png)]
使用面向对象的方式来解决养猫的问题
//实例化一只猫[创建一个猫对象]
-
// new Cat () 创建一只猫
-
// Cat cat1 = new Cat(); 把创建的猫赋给 cat1
Cat cat1 = new Cat();
cat1.name = “”;
cat1.age = ;
car1.color = “”;
-
Cat cat2 = new Cat(); //创建第二个猫对象/实例化另一只猫
cat2.name = “”;
cat2.age = ;
car2.color = “”;
System.out.println("第一只猫信息"+ cat1.name + cat1.age+cat1.color);
System.out.println("第二只猫信息"+ cat2.name + cat2.age+cat2.color);
class cat{
//属性
String name;
int age;
String color ;
最低0.47元/天 解锁文章
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
