复习(重点)
()括号里的面试问你了再答：
什么是重载
是在一个类下，方法名相同，形参列表不同，与返回值和修饰符无关，拥有两个或以上的方法
(同一个类的异议：子类继承父类的方法之后，这个方法就相当于是子类的方法，所以这个时候重载就满足在同一个类中)
(形参列表的顺序、个数、类型有一个不同就行)
介绍一下数组：(按wwwh解释)
数组是引用数据类型变量
使用步骤：
数组的赋值方式：静态、动态、默认(声明后就有默认值)
原因：存储大数据量信息
优点：索引遍历数据/随机查找元素速度快
缺点：不能动态赋值，长度固定，增加、删除数据麻烦(集合来解决)
特点：数组类型可以任意，数组元素的类型必须统一
索引下标从0~数据名.length-1
数组长度一旦确定不可改变
二维数组(理解)
public class Demo1 {
public static void main(String[] args) {
//接收某年级3个班，每个班5名同学的成绩，之后将成绩打印
int [][] arr = new int[3][5];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {//遍历3个班
System.out.println("请输入"+(1+i)+"班的");
for (int j = 0; j < arr[i].length; j++) {//遍历每个班的5个同学
System.out.print("第"+(j+1)+"个同学的成绩：");
arr[i][j] = sc.nextInt();
}
}
for (int[] i:arr) {
// for (int j:i) {
// System.out.print(j+"\t");
// }
System.out.println(Arrays.toString(i));
}
}
/*
【二维数组】(会操作即可)
维：跟生活中的维度不是一回事
数组中的维： 直接存储变量的数组叫一位数组
元素是一位数组的数组叫二维数组
学习多维数组的原因：
为了存储更多的数据信息。--->关系型数据库--->redis NoSqlDB非关系型数据库/内存数据库
使用二维数组：
1.声明二维数组：
数据类型 数组名;
int[][] arr;
2.分配空间：
arr = new int[][];//第一个中括号表示1维数组的空间长度
//第二个中括号的值表示每一个二维数组的空间长度，
没有值表示二维数组的空间可以不一致
合并：int[][] arr = new int[3][];
3.赋值：
静态赋值：声明 分配空间 同时赋值 int[][] arr={{1,2},{2,3}};
int[][] arr = new int[][]{{1,2},{2,3}};
动态赋值：单独为元素赋值arr[0]={12,23}; int[] nums={12}; arr[1] = nums;
默认赋值：声明同时分配空间
4.使用：
任何操作都要借助二重循环
*/
}
排序(会写)
冒泡排序代码
public class TestBubbleSort {
public static void sort(int[] a) {
int temp = 0;
// 外层循环，它决定一共走几趟
for (int i = 0; i <a.length-1; ++i) {
//内层循环，它决定每趟走一次
for (int j = 0; j <a.length-i-1 ; ++j) {
//如果后一个大于前一个（从大到小）
if (a[j + 1] < a[j]) {
//换位
temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;
}
}
}
}
public static void sort2(int[] a) {
int temp = 0;
for (int i = 0; i <a.length-1; ++i) {
//通过符号位可以减少无谓的比较，如果已经有序了(没交换过)，就退出循环
int flag = 0;
for (int j = 0; j <a.length-1-i ; ++j) {
if (a[j + 1] < a[j]) {
temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;
flag = 1;//没交换过说明有序
}
}
if(flag == 0){ break;}
}
}
}
选择排序的代码
public class TestSelectSort {
public static void sort(int arr[]) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
// 认为目前的数就是最小的, 记录最小数的下标
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
// 修改最小值的下标
minIndex = j;
}
}
// 当退出for就找到这次的最小值
if (i != minIndex) {
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
}
插入排序的代码
public class TestInsertSort {
public static void sort(int arr[]) {
int i, j;
for (i = 1; i < arr.length; i++) {
int temp = arr[i];
for (j = i; j > 0 && temp < arr[j - 1]; j--) {
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
}
面向对象(理解)
背下面干货分享
/*教案的面向对象案例素材3
OOP第一步：创建类
类名：Teacher
*/
public class Teacher {
/*
OPP第二步：确定属性
name：老师姓名
subject：教学科目
TeachingYears：授课年限
*/
String name;
String subject;
int teachingYears;
/**
* OOP第三步：确定方法：通过参数设置授课地点
* @param teachingLocation
*/
public void teaching(String teachingLocation){
System.out.println("在"+teachingLocation+"上"+subject+"的老师是"+name+"，他具有"+teachingYears+"年教龄");
}
/*
【面向对象】
1.为什么要学习‘面向对象’
随着互联网行业的发展，项目越来越大，越来越复杂，急需一种新的
软件开发方法来解决当前项目中的问题(只关注项目的实现步骤，项目的扩展性、重用性较低)
面向对象 思想帮忙解决。
【面向过程和面向对象两者是相辅相成的，不是替代的关系，是合作的关系：
宏观上通过面向对象来分析系统中，群体之间的复杂关系
微观上通过面向过程来做具体的实现】
2.面向对象如何解决问题？
只需要将生活中的解决方式经过一个很小的转变就可以直接作为java程序的开发思路。
3.面向对象的三个阶段：
1)面向对象分析OOA
2)面向对象设计OOD
3)面向对象编程OOP（要知道OOP是什么）
4.实现OOP的步骤：
1)[确定类]
分析/研究当前系统中，我们需要操作和管理的对象群体是谁，将该类群体抽象成为java类
4.1介绍类的对象：
【类的定义】具有相同属性和共同行为的一组对象的集合就叫类。
【接口的定义】具有共同行为的几组对象的集合就叫接口。（关注的是行为，谁实现接口谁有这个行为(表现形式可能不同)）
类是抽象的，对象是具体的，对象是一个具体存在的。
例：惠常哲(对象的属性) 是 学生(类)
2)[确定属性]
确定该对象群体与本项目有关的(所需要的)属性。
3)[确定行为](方法)
确定该对象群体与本项目有关的(所需要的)行为操作。
4)创建对象
5)对象属性赋值，对象调用方法。-------到此问题解决。
*/
}
public class Demo2 {
public static void main(String[] args) {
//引用数据类型的使用步骤
//声明同时赋值
Teacher teacher = new Teacher();
teacher.name = "张天宝";//要是和Teacher不在一个包下用不了，因为默认修饰符
teacher.subject="物理";
teacher.teachingYears=10;
teacher.teaching("阶梯教室");
Teacher teacher1 = new Teacher();
teacher1.name = "刘钰";
teacher1.subject="数学";
teacher1.teachingYears=25;
teacher1.teaching("中心礼堂");
}
}
其他(重点)
面向过程和面向对象两者是相辅相成的，不是替代的关系，是合作的关系：(看下面面试题)
宏观上通过面向对象来分析系统中群体之间的复杂关系
微观上通过面向过程来做具体的实现
类的定义：
具有相同属性和共同行为(方法)的一组对象的集合就叫类。
具有共同行为的几组对象的集合就叫接口。
面向对象编程OOP步骤：
- 确定类名叫什么
- 确定类里有多少个属性，每个属性叫什么名字（只定义，程序中涉及的属性）
- 确定类里有多少个方法，每个方法叫什么名字；方法体（只定义，程序中涉及的方法）
- 通过类new创建对象，通过对象调用方法。完成任务/功能。
属性用于定义该类或该类对象包含的静态特征。属性作用范围是整个类体。
方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。
局部变量和成员变量(重点)
背下面干货分享
/*对属性不同的称呼：
局部变量、成员/全局变量、实例变量、类变量
全局变量/成员变量(类里方法外的变量)<-->局部变量:(方法里的变量)
成员变量分为：
实例变量(归属于某一个对象)(通过对象.调用)<-->类变量(归属于某一个类，所有对象共享该类的类变量)(通过类.调用)static
【局部变量和成员变量的区别】：
1.位置不同：
成员变量：方法外，类里
局部变量：方法里、代码块里
2.作用域范围：
成员变量：当前类下，其他类中
局部变量：当前方法里、当前代码块里
3.默认值不同：
成员变量：有默认值(0、0.0、false、null)
局部变量：没有默认值
4.内存位置不同：
成员变量：堆内存(对象的变量，因为是引用数据类型)
局部变量：栈内存(引用存地址，基本存数值)
5.存活时间：
成员变量：从对象创建开始，到垃圾回收机制清除内存结束。
局部变量：从声明开始，到所在的方法/结构结束而清理。
6.同名问题：
成员变量：不允许同名
局部变量：作用域没交集的时候可以同名
---------成员变量和局部变量可以同名(下面是用的情况)
7.优先级问题：
成员变量：this.变量名调用
局部变量：直接用*/
区别 | 成员变量 | 局部变量 |
|---|---|---|
| n内存位置不同 | 堆内存(对象的变量，因为是引用数据类型) | 栈内存(引用存地址，基本存数值) |
| t同名问题 | 不允许同名 | 作用域没交集的时候可以同名 |
| m默认值不同 | 有默认值(0、0.0、false、null) | 没有默认值 |
| w位置不同 | 方法外，类里 | 方法里、代码块里 |
| x幸存时间 | 从对象创建开始，到垃圾回收机制来清除占用的内存空间 | 从声明开始，到所在的方法/结构结束而清理 |
| y优先级问题(就近原则) | this.变量名调用 | 直接用， |
| z作用域范围 | 当前类下，其他类中 | 当前方法里、当前代码块里 |
构造方法(重点)
public class Demo3 {
public static void main(String[] args) {
Teacher teacher = new Teacher("惠常哲","哈哈哈",24);
teacher.teaching("教室");
}
/*
【构造方法(构造器)】：(接口中没有)
构造方法的作用？
实例化：创建对象
初始化：为对象的属性赋初始值
什么是构造方法？
类的组成部分，一个特殊的方法，
1.方法名必须和类名相同
2.没有返回值类型，连void都没有
3.开发者不创建，程序自动提供无参构造(公共的无参的方法体为空的)(手动创建构造方法后消失)
【一个类中，可以没有属性，可以没有普通方法，但一定有构造方法】
4.通过new关键字调用构造方法 普通方法通过.调用
5.构造方法之间只能互相调用，通过this()关键字调用,且放在第一行
6.构造方法也可以有方法的重载
7.构造方法可以为private，只能本类下使用(存在的必要：单例模式(本类下this()调用))
*/
}
public class Teacher {
String name;
String subject;
int teachingYears;
public void teaching(String teachingLocation){
System.out.println("在"+teachingLocation+"上"+subject+"的老师是"+name+"，他具有"+teachingYears+"年教龄");
}
public Teacher(String name, String subject, int teachingYears) {
this.name = name;
this.subject = subject;
this.teachingYears = teachingYears;
}
public Teacher() {
}
}
构造方法的特点：接口没有构造器
方法名必须和类名相同没有返回值类型，连void都没有开发者不创建，程序自动提供无参构造(公共的,无参的,方法体为空的)(手动创建构造方法后消失)【一个类中，可以没有属性，可以没有普通方法，但一定有构造方法】创建对象时通过new关键字调用构造方法 普通方法通过.调用构造方法之间只能互相调用，通过this()关键字调用,且放在第一行
构造方法也可以有方法的重载
构造方法可以为private，只能本类下使用(存在的必要：单例模式(本类下this()调用))
阿里归约要求类里一定要有无参构造器自己写有参后一定要加无参构造
作用：
实例化对象然后初始化赋值
面试题(重点)
类和对象的关系
类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。
面向过程和面向对象的区别
两者都是软件开发思想，先有面向过程，后有面向对象。在大型项目中，针对面向过程的不足推出了面向对象开发思想。
"高内聚，低耦合"
➢高内聚:类的内部数据操作细节自己完成，不允许外部干涉;
➢低耦合:仅对外暴露少量的方法用于使用。
区别
- 编程思路不同： 面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能。
- 封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能。
- 面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势是明显。
214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
