导图社区 java技术基础和面对对象
- 20
- 0
- 0
- 举报
java技术基础和面对对象
java技术基础和面对对象知识总结，包括初识Java语言、常量变量、运算符和总结梳理、程序的基本结构、循环进阶和数组入门等内容。
编辑于2022-06-26 11:08:25- 技术
- 相似推荐
- 大纲
java技术基础和面对对象
第一章：初识Java语言
Java语言的特点
具有简单性，面向对象，分布性，健壮性，安全性，平台独立与可移植性，多线程，动态性等特点。
手写Java代码步骤
1.编写java源文件.后缀
2.编译源文件 java原文件名称.Java
3.运行字节码文件 java 文件名
"\t"制表符表示空格
"\n"制表符表示换行
\"\"制表符表示引号字符
第二章：常量变量
数据类型
整数型 byte，short，int，long
浮点型 float，double
字符型 char
布尔型 boolean true（对）false（错）
字符串 string
字节 1B=8BIT ，1KB=1024KB，1MB=1024KB，1GB=1024MB，1tb=1024GB
变量
1.用来储存数据的内存单位。2.可以反复储存，第二次储存会把第一次储存数据覆盖。
语法规则
数据类型 变量名=数据值
int a（自己取名） = 100；
命名规范
英文字母 a-A，A-Z
数字 0-9 但数字不能作为开头
符号 _和$
中文拼音
class，public，static，viod，mian这些单词开发者赋予了特殊含义不能使用这些敏感词
命名是不能有空格
变量使用规则
1.要先定义在赋值。也可以定义时在赋值，也可以先定义完毕，在进行赋值
2.变量名不能重复使用
3.可以多次可以反复储存，第二次储存会把第一次储存数据覆盖
常量
常量是在程序中不能被修改的数据 如:PI=3.14
final 数据类型 常量名 = 常量值
规则 常量命名要全部是大写
第三章：运算符和总结梳理
数据类型转化
转化规则：低级别的数据类型赋值给高级别类型时，进行自动转换
强制转换规则语法：目标类型 变量名=（目标类型）代转换变量
运算符
算数运算符：+，-，*，/，%，++，--
赋值运算符：=，+=（加后赋值）。-，-=（减后赋值）......
比较运算符：布尔类型 ture或false
逻辑运算符：
与运算符&&：两个条件同时为true，计算结果为true。只要有一个false结果为true；如果第一个为false那么结果为false后面不参与运算。
&：如果第一个为false那么后面表达式会参与运算。
或运算符：如果表达式第一个为true后面第二个表达式不运算，直接运行当前表达式；如果第一个表达式false就运行第二个表达式，如过第二个表达式为true就运行，如果为false就退出。
非运算符：！取它的反值。如果表达式为true在前面加！结果为false，反之为true。
条件运算符：条件？表达式1：表达式2； 运算规则：首先进行判断，如果计算条件为true，返回表达式为1，否则返回值为2。
第四章：程序的基本结构（一）
程序三种结构：1.顺序结构 2.选择结构 3.循环结构
if 的语法结构：if（判断条件）{ 当条件为true执行语句 }当条件为false执行的语句
if....else的语法结构：if（判断条件）{ 当条件为true执行语句 }else{ 当条件为false执行的语句 }
多个if....else语法结构：if（条件1）{ 当条件满足条件1执行语句 } else if （条件2）{ 当条件满足条件2执行的语句 } else {当两个条件都不满足的条件下执行}
嵌套if...else：if（判断条件）{ 当条件为true执行语句if（判断条件）{ 当条件为true执行语句 }else{ 当条件为false执行的语句 } }else{ 当条件为false执行的语句 }
Switch...case 等值判断的时候：Switch(表达式) { case 目标值1：执行语句 1; break case 目标值2：执行语句 2; break case 目标值3：执行语句 3; break} 表达式计算的值的类型：byte，char，short，int
第五章：程序的基本结构（二）
循环结构的分类：1.which循环 2.do...which 3.for循环 4.增强for循环
which循环的语法：which（循环条件）{执行语句 //由于要执行的语句是有次数的，否则会造成死循环。所以当执行一定次数后要让循环为false结束}
do...which的语法结构：do { //循环体} which（循环条件）；
for循环语法：for（初始表达式；循环体；操作表达式）{ 循环体 } 运行顺序：for（ 1,2,4 ）{ 3 }
増强for循环了解即可
第六章：循环进阶和数组入门
双重for循环：for（初始表达式；循环体；操作表达式）{ 循环体 for（初始表达式；循环体；操作表达式）{ 循环体 } } 1.外层控制打印的行数。2.内层控制的是打印的个数。
break 用法：当break出现在循环中的时候，会终止循环的执行，跳出循环，执行后面循环语句
continue 用法:当continue出现在循环中的时候，会终止本次循环的循环，如果条件满足进入下次循环
数组的概念和用法
数组：就是使用相同的类型来定义一组变量的问题
数组语法：数据类型[ ] 数组名=new 数据类型[数组长度] 调出：数组名.length
二维数组
二维数组语法：数据类型[ ] [ ] 数组名=new 数据类型[数组长度] [数组长度] 相当于每个数组中的长度
存储数据：arr[0][0]=1;表示第1行的第1列的赋值 ，arr[0][1]=2;表示第2行的第1列的赋值 注意事项：索引是从0开始不可更改
二维数组输出：for(int i=0,i<数组名.length，i++){ for(int j=0,j<数组名[i].length，j++){ sout } }
第七章：数组综合应用和Arrays工具类
数组综合案例练习
Arrays工具类的使用
Arrays使用：类名.方法（参数）
binarysearch():二分法搜索
sort():排序
copyof():复制数组中的元素
copyofrange():复制数组中指定范围的元素
fill():填充元素
通string():将数组元素转化为字符串
Arrays工具类是为了减少每次编码，可以将要实现的功能写到一个类中，下次使用直接调用，不需要再重复编写，这样的类就都是工具类。
第八章：方法的调用和重载
从Arrays工具类到方法的调用
可以反复调用，可以减少我们写的代码，提高我们的工作效率
方法的分类：成员方法，静态方法，构造方法
静态方法：修饰符 返回值 方法名 （参数类型1，参数类型2，参数类型3，....）{ 执行语句 return 返回值 }
例如：public stitch int（int a，int b，int c）{ sout }
形参和实参
形参的作用：它就是用来接收主调函数传递到函数的数据的。
（有数据名但没有变量值是形参）
实参的作用：主调函数的数据用于给被调函数
（有变量值但没有数据名是实参）
静态方法的重载
什么是方法重载：如果在一个类中，多个方法名的名字相同，形参的个数或者是形参的数据类型不相同，这就是所谓的方法的重载
什么时候用方法重载：解决相同类型的问题，在java中运行在一个类中定义多个名字相同的方法
注意事项：返回值不能重载，因为区分重载的标志是参数的个数或者类型不一样
第九章：吃货联盟综和案例
吃货联盟案例：
public class ChiHuoLianMeng {
public static void main(String[] args) {
// 菜品名称 String[] dishNames = new String[3]; // 菜品价格 double[] dishprice = new double[3]; // 点赞数 int[] points = new int[3];
// 订餐信息 // 订餐人 String[] names = new String[5]; // 订餐信息 String[] dishMegs = new String[5]; //送餐时间 int[] times = new int[5]; // 订餐地址 String[] address = new String[5]; //订餐状态 int[] states = new int[5]; // 订单总价格 double[] sumPrices = new double[5];
init(dishNames,dishprice,points,names,dishMegs, address,times,states,sumPrices);
// 调用菜单 select(dishNames,dishprice,points,names,dishMegs, address,times,states,sumPrices);
} public static void init(String[] dishNames , double[] dishprice ,int[] points , String[] names ,String[] dishMegs ,String[] address , int[] times ,int[] states, double[] sumPrices ){
// 菜品相关的内容 dishNames dishNames[0] = "鱼香肉丝"; dishNames[1] = "鱼香肉丝"; dishNames[2] = "鱼香肉丝";
// 菜品的价格 dishprice dishprice[0]=9.9; dishprice[1]=28.9; dishprice[2]=52.9;
// 菜品点赞数量 points[0]=1; points[1]=0; points[2]=2;
// 订单人 names names[0]= "张三"; names[1]= "张三"; names[2]= null; names[3]= null;
// 菜品信息 dishMegs dishMegs[0]= "鱼香肉丝 2份"; dishMegs[1]= "大盘鸡 2份"; dishMegs[2]= "大盘鸡 2份";
// 订餐地址 address address[0]="河南省"; address[1]="周口市"; address[2]= null; address[3]= null;
// 订餐时间 times times[0]= 10; times[1]= 12; times[2]= 13; times[3]= 11;
// 订餐状态 states states[0]=0; states[1]=1; states[2]=0; states[3]=1;
// 订餐总价 sumPrices sumPrices[0]=119.7; sumPrices[1]=90; sumPrices[2]=54; sumPrices[3]=119.7;
} public static void select(String[] dishNames , double[] dishprice ,int[] points , String[] names ,String[] dishMegs ,String[] address , int[] times ,int[] states, double[] sumPrices){ Scanner ww = new Scanner(System.in);
// 定义判断值 boolean flag=false;
// 定义变量接收用户输入的数 int num = 0;
do {
// 调用方法 shuchu();
// 接收用户输入的数 num= ww.nextInt();
switch (num){ case 1: //实现订餐的过程
// 调用订餐的方法即可 order(dishNames,dishprice,points,names,dishMegs, address,times,states,sumPrices); break; case 2: //实现查看订餐的过程 // 调用查看订餐的方法即可 lookup( names , dishMegs,times, address, sumPrices,states); break; case 3: //实现签收订单的过程 // 调用签收订单的方法即可 signorder(names , dishMegs,times, address, sumPrices,states); break; case 4: //实现删除订单的过程 // 调用删除订单的方法即可 deleteorder(names , dishMegs,times, address, sumPrices,states); break; case 5: //实现点赞的过程 // 调用点赞的方法即可 // point(); break; case 6: flag=true; break; default: flag=true; break; } if (flag==false){ System.out.println("请输入一个0返回选择菜单"); num = ww.nextInt(); } }while (num==0); System.out.println("谢谢使用，退出系统");
}
// 欢迎界面，用户进入系统就可以看到 public static void shuchu(){ System.out.println("欢迎使用\"吃货联盟订餐系统\""); 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("6.退出系统"); System.out.println(" * "); System.out.println("请选择："); }
// order---实现订餐功能 public static void order(String[] dishNames , double[] dishprice ,int[] points , String[] names ,String[] dishMegs ,String[] address , int[] times ,int[] states, double[] sumPrices){ Scanner qq = new Scanner(System.in); System.out.println("
订餐功能 "); System.out.println("请输入订餐人的姓名："); //用name变量来接收用户输入的订餐人姓名 String name = qq.next(); //把当前店铺所有的菜品显示出来让用户选择 System.out.println("序号\t\t菜品名称\t\t菜品价格"); // 通过数组历遍来显示菜品名称和价格 for (int i = 0; i <dishNames.length; i++) { System.out.println((i+1)+"\t\t\t"+dishNames[i]+"\t\t"+sumPrices[i]); } System.out.println("请输入你要点的菜品编号："); // 用一个变量bianhao来接收用户选的菜品编号 int num = qq.nextInt(); System.out.println("请输入你要点的菜品份数"); // 用一个变量fenshu来接收用户选的菜品数量 int fenshu = qq.nextInt(); System.out.println("请输入送餐时间"); // 用一个变量shijian接收用户选的订餐时间 int shijian = qq.nextInt(); System.out.println("请输入送餐地址："); // 用一个变量dizhi来接收用户选的订餐地址 String dizhi= qq.next();
// 实际订餐功能就是把所有订单信息添加到相应数组中，所以我们要找出一个插入位置 //从某个数组中进行查找空位置，如果找到了说明空间还有位置可以增加新内容， // 这个过程找到这个位置就是接下来我们新增加内容到数组的一个下标 int index=-1; // -1表示没有可插入的位置 for (int i = 0; i <names.length ; i++) { if (names[i]==null){ index=i; break; } }
/*订餐人姓名 /*订餐菜品 菜 价格 /*订餐时间 /*订餐地址 /*订餐价格 * */ String caipinming = null; double caipinjiage = 0.0; if (index!=-1){ names[index]=name; } for (int i = 0; i <dishNames.length ; i++) { if (num==(i+1)){ caipinming=dishNames[i]; caipinjiage=dishprice[i]; break; } } dishMegs[index]= caipinming +" "+ fenshu +"份"; times[index]=shijian; address[index]= dizhi; double peisongfei = fenshu*caipinjiage>50?0.0:6.0; sumPrices[index]=fenshu*caipinjiage+peisongfei; System.out.println("订餐成功"); System.out.println("您的订餐时："+dishMegs[index]); System.out.println("您要求的送餐时间是："+times[index]); System.out.println("您的订餐地址是："+address[index]); System.out.println("餐费是："+fenshu*caipinjiage+",送餐费是"+peisongfei+" "+"总计："+sumPrices[index]);
//lookup---实现查看订单功能 private static void lookup(String[] names ,String[] dishMegs,int[] times,String[] address, double[] suprices,int[] states){ System.out.println("
查看订餐 "); System.out.println("序号\t\t\t菜品信息\t\t\t送餐时间\t\t送餐地址\t\t总金额\t\t订餐状态"); for (int i = 0; i <names.length ; i++) { if (names[i]!=null){ String state = states[i] ==0?"已预订":"已完成"; System.out.println((i+1)+"\t\t\t"+dishMegs[i]+"\t\t\t"+times[i]+"\t\t\t"+address[i]+"\t\t\t"+suprices[i]+"\t\t\t"+state); } } }
//signorder---实现订单签收功能 private static void signorder(String[] names ,String[] dishMegs,int[] times,String[] address, double[] suprices,int[] states){ Scanner qq = new Scanner(System.in); System.out.println("
签收订单 "); System.out.println("请输入你要签收的订单号："); int orderid = qq.nextInt(); / 一.找一个订单，然后通过这个订单号states数组中对应下标存的值states[i]=1； 二.一些限定条件
1.用户输入的订单号 是不是 要等于 i+1
2.找到states数组中的元素，判断一下是否存的是否是1，只有是0的情况才能签收
3.限定一下状况，限定订单人的这个元素不能为空 *
*/ boolean flag = false; for (int i = 0; i <names.length ; i++) {
if (names[i]!=null&&states[i]==0&&orderid==(i+1)){ states[i]=1; System.out.println("订单签收成功"); flag=true; }else if (names[i]!=null&&states[i]==1&&orderid==(i+1)){ System.out.println("订单已签收，不能重复签收"); flag=true; break; }
} if (flag==false){ System.out.println("订单不存在"); }
} //deleteorder---实现删除订单功能 private static void deleteorder(String[] names ,String[] dishMegs,int[] times,String[] address, double[] suprices,int[] states){ System.out.println("
删除订单 ");
Scanner qq = new Scanner(System.in); System.out.println("请输入您要删除的订单："); int orderld = qq.nextInt(); boolean isdel = false; for (int i = 0; i <names.length ; i++) { if (names[i]!=null && states[i]==1&& orderld==i+1){ for (int j = orderld-1; j <names.length-1 ; j++) { names[j]=names[j+1]; dishMegs[j]=dishMegs[j+1]; times[j]=times[j+1]; address[j]=address[j+1]; states[j]=states[j+1]; suprices[j]=suprices[j+1]; } names[names.length-1]=null; dishMegs[names.length-1]=null; times[names.length-1]=0; address[names.length-1]=null; states[names.length-1]=0; suprices[names.length-1]=0; System.out.println("删除订单成功！"); isdel=true; break; }else if (names[i]!=null && states[i]==0&& orderld==i+1){ System.out.println("您的订单未签收，不能删除"); isdel=true; break; } } if (isdel==false) { System.out.println("您要删除的订单不存在！"); }
} //point---实现点赞功能 private static void point(String[] dishNames, double[] suprices,int[] dishprice){ System.out.println("
我要点赞 "); Scanner qq = new Scanner(System.in); System.out.println("序号\t\t菜品\t\t单价"); for (int i = 0; i < dishNames.length ; i++) { System.out.println((i+1)+"\t"+dishNames[i]+"\t"+suprices[i]+"\t"+ dishprice); } System.out.println("请输入您要点赞的菜品名："); int q= qq.nextInt(); // dishprice=[q-1]++; System.out.println("点赞成功"); }
面向过程过渡到面向对象
面向过程和面向对象是编程的两种思维方式
面向过程是自己每一步亲力亲为，控制每一个步骤的实施；思考“我该怎么做”，然后一步步实现的过程。（自己是执行者）
面向对象是找一个对象，这个对象必须满足具备完成这个业务的能力，然后我们只要把对象找的，让对象来做就完毕（找到对象-执行者 自己-指挥者）
第十章：类和对象
什么是类？
类是具有相同属性和行为的集合或者统称
什么是对象？
对象就是由类创建出来的实体
类和对象的关系是什么？
类是模板，对象是由模板创建的具体的实例，类是抽象的概念，它里面封装了对象具体的功能
类和对象的语法
1.编码步骤
创建类（成员变量和成员方法）
通过类创建对象
初始化成员变量
操作方法完成业务逻辑
2.如何创建类
public class 类名{
构造方法 //构造方法-用来进行对成员变量初始化 成员变量 //可以编写0到n个成员变量-属性 成员方法 //可以编写0到n个成员方法-行为
3.成员变量语法
访问的修饰符 数据类型 变量名1；
访问的修饰符 数据类型 变量名2；
4.成员方法的语法
修饰符 返回值的类型 方法名（类型 形参1，形参2，形参3......）{
语句块； return 返回值；
5.如何在类中创建建对象
类名 对象名 = new 类名（）；
6.如何使用成员变量（属性）
1.赋值
对象名.属性=值；
2.取值
对象名.属性；
局部变量和成员变量
1.什么是局部变量？
答：第一在方法中的变量或者是声明方法的时候，数据类型是基本数据类型的形参，我们称为局部变量 （写在方法内或者方法的形参表里）
2.什么是成员变量？
答：在类中定义的变量，不是在方法体内部定义的，就是成员变量 （写在类内或方法外）
3.局部变量和成员变量同名时候，在方法体中怎样使用成员变量？
答：如果在方法体中调用和局部变量相同的成员变量，可以使用this.成员变量的方式进行
技能小结
1.形参也属于局部变量
2.可以通过this关键词操作同名的成员变量
3.多个方法共享使用成员变量的时候，在一个方法中对成员变量的值进行了修改，那么其它的方法使用的时候，以最后修改的结果为准
4.不能再一个方法中使用另一个方法的局部变量
类在内存中的结构
1.java虚拟机载入代码到内存
2.main（）方法入栈区
3.如果遇到类对象，而且对象使用new关键词，就会在堆中进行空间分配。局部变量在刚刚开辟的栈空间中赋值。把对堆开辟的空间地址赋值给类对象
4.如果执行对象的方法，那么调用方法开始入栈。如果调用方法中有有局部变量，就在方法所分配的栈中开辟空间，并存储数据。当对象的方法执行关闭后，调用的方法入栈
5.main（）方法中的所有代码执行完毕后，main（）方法找出栈
第十一章：方法的调用，封装，继承
静态方法的使用
语法：
访问修饰符 static 返回值的类型 方法名（形参列表） { //业务代码 return 表达式；
成员方法的使用
语法：
访问修饰符 返回值的类型 方法名（形参列表） { //业务代码 return 表达式；
对象数组的使用
1.什么是对象数组？
答：如果数组的元素的类型时类类型（对象类型），那么这样的数组是对象数组
2.对象数组初始化和数组元素（对象）的初始化
答：例如 比如学生管理系统的类A中包含属性是一个数组对象student [ ] stu=new student [ ]，然后在测试类的main（）方法中初始化了A的对象，初始化对象数组的各个元素。
封装和this关键字
面向对象的三大特点：封装，继承，多态
this关键字是什么？
1.this在成员变量的名字和局部变量的名字一样时，在一个方法中要使用成员变量可以使用this.成员变量去操作
2.谁调用，那么this就指向谁的引用，可以理解成是当前对象的引用。它实际指向的是堆中的一个对象
继承
继承的优点（为什么要继承）
1.继承的出现提高代码的复用性，提高软件开发的效率
2.继承的出现，让类和类之间产生了关联，提供了实现多态的前提
继承语法：
public class 子类名 extend 父类名{ //扩展0-n个特有属性 //扩展0-n个特有方法 }
什么是继承？
答：很多时候我么会在一个类的基础上继承去创建一个新的类，那么本来是父类，新类是子类，子类会继承父类的非私有属性和成员方法
继承规则
1.一个子类自能有一个直接父类，不能有多个父类。但是可以有多个间接父类
2.间接父类与直接父类的关系
答：编写类A，类B和类C，让类B继承类A，再让类C继承类B
super关键字
作用：当子类中有与父类同名的属性的时候，如果要在子类中使用父类同名的属性，可以使用super属性
重写和重载
1.什么事重写？
当子类继承父类的元素和方法的时候，如果他们不能满足子类的业务需要，我们可以对方法在子类中进行重写的编写。这就是重写。
2.重写规则？
在子类中重写的方法的时候的返回值类型，方法名，参数列表要一样。
子类中重写的方法的访问修饰符的访问权限必须大于或者等于父类的访问权限
3.重载和重写的区别？ 课本155页
第十二章：抽象类，构造方法
抽象类的语法
public abstract class 类名{
//可以编写0-n个抽象方法的声明，方法没有实现体 public abstract 返回值 方法名（形参列表）
抽象类的相关规则
1.抽象类和抽象方法都要用abstract修饰。抽象方法一定在抽象类中，但是抽象类不一定有抽象方法
2.抽象类不可以直接被实例化
3.只有重写了抽象类中的所有抽象方法，子类才可以创建对象。否则该子类一定还是一个抽象类
4.抽象类的的关键字abstract不可以和这几个关键字同时使用，private，final，static
构造方法
为什么需要构造方法？
就是用来给成员变量去初始化
构造方法的语法
访问修饰符 类名 （形参列表）{
//给成员变量赋初值
构造方法的使用规则
访问修饰符
访问修饰符的作用
用来修饰类中的属性和方法的可见性（可访问性）
java中的几种访问修饰符
public，protect，默认，private
使用规则
1.无论用了任何访问修饰符，再类中都可见
2.public：被改访问修饰符修饰的类或类中属性，方法可以被所有的类访问，不受包的限制
3.protect：子类可见，同包可见
4.默认：同包可见
5.private：本类可见
第十三章：接口
接口是什么？
假如A要继承B，同时还要继承C不允许间接继承， 那么 ，此时可以把抽象C写一个接口，让A继承B同时实现接口C。
什么时候需要接口？
1.如果父类都是抽象方法的声明，业务又遇到了多继承的场景，此时可以变通的把父类写出接口。因为这样就可以单继承，同时实现多个接口
2.如果多个类，具有公共的方法，但是无法找到父类。没有is a的关系。此时写出接口。接口本身体现的是一种扩展功能
语法规则
一个类可以继承一个父类，但可以实现多个接口
public class D extend C implement A，B{ //内容
第十四章：面向接口编程，多态
多态概念
多态是什么？
是面向对象的三大特征之一。在java当中，多态的代码体现在一个子类对象既可以给这个子类引用变量赋值，也可以给这个子类的父类（接口）进行赋值
在java中，为什么要设计成这样的语法特点（为什么有多态）
因为在面向对象的设计原则中，很关键的一条就是需要减少类和类之间的耦合，我们是充分利用了接口的定义和实现可以进行分离的原则。那么多态就可以帮助我们做到这一点，没有多态，无法做到解耦
向下转型和向上转型
什么是向上转型
语法： 父类类型 对象名=new 子类（）；
将子类转成父类，就是所谓的向上转型
什么是向下转型
语法： 子类类型 对象名= （子类类型）父类对象；
将父类转成子类，就是所谓的向下转型
规则
当向下转型的时候，一定要保证被转换的对象在内存中的真实类型和转换的类型一致否则报错