本文详细介绍了Java中的方法定义、数组操作及面向对象的基础概念，包括方法的格式、方法重载、数组的初始化、遍历、查找、排序，以及面向对象的特性。内容涵盖静态与动态初始化方法、数组的基本应用、冒泡排序算法，并讨论了面向对象编程中的类、对象、封装和测试类的概念。
少时不懂其中意,长大方知父母恩
前面内容请见:
JAVA基础–JAVA SE(知识点总结 Ⅰ )
JAVA基础–JAVA SE(知识点总结 Ⅱ )
以下是我们今天的内容:
本文目录
一.方法
1.方法
- 在Java中,使用{}代码块,将我们的业务逻辑进行实现,给{}起一个名字,就是方法.
2.方法的格式
-
在Java中,定义方法的格式(有两种)
-
第一种:
-
有具体返回值的方法定义
-
-
格式
public static 返回值类型 方法名(形式参数类型1 参数名1,形式参数类型2 参数名3....){ //业务逻辑进行实现 return 具体的结果; } -
解释说明
-
public:权限修饰符:公共的公开的/访问权限足够大 -
static:静态修饰符(面向对象中) -
返回值类型:就是数据类型,现在只学习了基本数据类型, -
方法名:满足标识符的规范 :方法名和变量名, "小驼峰命名法" -
一个单词:字母小写 -
多个单词:第一个单词字母全部小写,从第二个单词开始,每一个单词首字母大写,其余小写
-
-
调用方法
- 赋值调用 接收的结果类型 变量名 = 方法名(实际参数1,实际参数2,…) ;(推荐)
public class FunctionDemo { public static void main(String[] args) { //赋值调用 int c = add(10,20) ; //中间有其他逻辑,再次使用c变量 System.out.println("两个数据求和结果是:"+c); } //定义一个方法:求和的方法, 两个数据 /*心中两个明确: a)明确方法返回值类型 int b)明确形式参数类型以及参数个数 两个参数:都是int */ public static int add(int a,int b){ //方法的业务逻辑:求和的方法, 两个数据 //return a +b ; //直接返回a+b的结果 //将a和b的结果赋值给一个变量 int result = a +b ; return result ; } } -
定义方法的注意事项
- 方法和方法是平级关系,不能够在一个方法中定义另一个方法,只能在一个方法中调用另一个方法
- 在定义方法的时候,方法中的形式参数必须带上数据类型,因为Java是一个强类型语言
- 调用方法的时候,实际参数不需要带数据类型
- 在定义方法的时候,有{的地方不能分号;,有分号;的地方不能{
- 有具体返回值类型的方法,必须要携带return,否则会报错
public class FunctionDemo2 {
//main方法
public static void main(String[] args) {
//调用sum方法
double a = 12.0 ;
double b = 13.5 ;
// double result = sum(double a, double b);//实际参数不能带数据类型了
double result = sum( a, b);//实际参数 它就是调用者
System.out.println("result:"+result);
}
//两个数据求和的功能
//返回值double
//两个参数,都是double
public static double sum( double x ,double y){
double result = x+ y ; //求和
return result ;
}
}
-
在Java中,定义方法的格式(有两种)
-
第二种
- 没有具体返回值类型的方法定义和调用
-
格式
public static void 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名2,....){ //业务逻辑进行实现 }
-
-
调用方法
- 单独调用
- 举例NN乘法表
public class FunctionDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请输入一个数据(1-9):");
int num = sc.nextInt() ;
//单独调用
printNN(num); //8
}
/**
* 定义 方法两个明确
* 1)明确返回值类型: java提供关键字 void
* 2)明确参数类型以及参数个数
* int类型 1个参数
*/
public static void printNN(int n){//8
for(int x = 1 ;x<=n;x++) { //外层控制行数
for(int y =1 ; y <=x ;y++){ //内层循环控制列数,列数随着行数的变化 第一行,1列,第二行,2列....
System.out.print(x+"×"+y+"="+(y*x) +"\t"); //不换行
}
System.out.println(); //换行
}
}
}
3.方法重载(补充)
-
为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同,与返回值无关
- 参数列表不同
- 参数个数不同
- 参数类型不同
- 参数类型的顺序
-
举例
/** * 需求:比较两个数据是否相等 * * 满足2个类型, * 两个int类型进行比较 * 两个double进行比较 */ public class OverLoadTest { public static void main(String[] args) { //定义两个变量 int a = 10 ; int b = 20 ; double x = 12.56 ; double y = 12.56 ; //重载方法 boolean flag = compare(a, b); boolean flag2 = compare(x, y); System.out.println(flag) ; System.out.println(flag2) ; } //两个int类型进行比较 public static boolean compare(int a,int b){ return a==b ; } //两个double类型进行比较 public static boolean compare(double a,double b){ return a==b; } }
二.数组
1.数组
-
Java中数组就是容器,这个容器 “只能存储同一种类型的元素”
-
在数组中定义格式
-
动态初始化
-
动态初始化:自己定义数组的长度,数组的元素有系统(jvm)默认分配
-
格式
-
数据类型[] 数组名称 = new 数据类型[数组长度] ; (推荐第一种) -
数据类型 数组名称[] = new 数据类型[数组长度] ;
-
-
举例
int[] arr = new int[7] ; int arr[] = new int[7] ;
-
-
静态初始化
-
静态初始化:直接我们自己给定的了元素内容,数组的长度由系统默认分配
-
格式
-
原生的格式写法:
-
数据类型[] 数组对象名 = new 数据类型[]{元素1,元素2,元素3.....} ; -
数据类型 数组对象名[] = new 数据类型[]{元素1,元素2,元素3.....} ;
-
-
举例
int[] arr = new int[]{1,2,3} ; int arr[] = new int[]{1,2,3} ; -
静态初始化的简写格式
-
数据类型[] 数组对象名 = {元素1,元素2,元素3.....} ; (推荐的写法) -
数据类型 数组对象名[] = {元素1,元素2,元素3.....} ;
-
-
举例
int[] arr = {1,2,3} ; int arr[] = {1,2,3} ;
-
-
-
补充:
- jvm的内存分配
-
栈内存 :存储的就是局部变量 -
堆内存 :以后 new出来的东西都在堆中 (new :创建对象) -
方法区 : * xxx.class :字节码文件区域 * static区域 * 常量池区域. -
寄存器 -- cpu和系统相关的 -
本地方法区 -- cpu和系统相关的
-
- jvm的内存分配
-
举例
- 已知一个数组:静态初始化,现在需要把数组的元素遍历出来
- 遍历:将数组的元素一一打印出来
- int[] arr = {24,87,56,17,13.35,78,86} ;
public class ArrayTest {
public static void main(String[] args) {
int[] arr = {24,87,56,17,13,35,78,86} ;
//调用方法遍历
printArray(arr);
}
public static void printArray(int[] array){ //形式参数
System.out.print("["); //[元素1, 元素2,,,
//遍历array数组
for(int x =0 ; x < array.length ; x ++){ //x角标
//这个角标如果取到了最大角标---- 最后一个元素 ,直接输出这个元素内容同时拼接 右]
if(x== array.length-1){
System.out.println(array[x]+"]");
// 最后一个元素]
}else{
//如果不是最后一个角标---- 取到的中间的元素,直接输出元素的内容 同时拼接 ", "
System.out.print(array[x]+", ");
}
}
}
}
2.数组中的基本应用(举例)
- 最值问题 (最大值/最小值)
-
已知一个数组,静态初始化,完成获取数组中最大值 -
分析: * int[] array = {65,45,76,87,13,36,98} ; * 定义一个参照物 array[0] 就是最大值 * 从角标1开始遍历数组的其他元素 * 判断:使用后面的元素依次和参照物比较 * 如果后面元素比参照物,将最大值修改了 * 最后获取最大值
-
public class ArrayDemo {
public static void main(String[] args) {
//创建一个数组静态初始化
int[] array = {65,45,76,87,13,36,98};
//赋值调用
int max = getArrayMax(array) ; //实际参数
System.out.println("max:"+max);
System.out.println("-----------------------------------------") ;
//获取数组最小值
int min = getArrayMin(array);
System.out.println("min:"+min);
}
public static int getArrayMax(int[] arr){
//定义参照物
int max = arr[0] ;
//从角标1开始遍历数组,获取每一个元素
for(int x = 1 ; x < arr.length ; x ++){
//判断
if(arr[x] > max){
//将后面的元素赋值给max
max = arr[x] ;
}
}
return max ;
}
//定义一个方法, 获取数组最小值
public static int getArrayMin(int[] arr){
//定义一个参照物 是最小值
int min = arr[0] ;
//从角标1开始遍历数组
for (int i = 1; i < arr.length; i++) {
//判断
//如果后面的元素比min还小,后面的元素是最小值
if(arr[i] < min){
min = arr[i] ;
}
}
return min ;
}
}
- 数组查表法:
-
给定一个数组,快速获取数组中的某个元素:数组名称[索引值] -
//字符串数组---里面存储字符串 -
//创建数组的格式:静态初始化 -
数据类型[] 数组名称 = {元素1,元素2,,..} ;
-
/**需求:
* 键盘录入一个数据:
* 显示"星期"*/
import java.util.Scanner;
public class ArrayDemo2 {
public static void main(String[] args) {
//键盘录入一个数据
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数字(0-6):") ;
int num = sc.nextInt() ;
String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
System.out.println("你查询的星期是:"+strArray[num]) ;
}
}
-
数组逆序
-
第一种
public class Reverse { public static void main(String[] args) { //静态初始化数组 int[] arr = {16,34,56,39,96,64,56,58,78,86}; System.out.println("逆序前的数组:"); printArray(arr); System.out.println("-------------------------------"); System.out.println("逆序后的数组(方法1):"); reverse(arr); printArray(arr); System.out.println("-------------------------------"); System.out.println("逆序后的数组(方法2):"); reserve2(arr); printArray(arr); } //遍历方法 public static void printArray(int[] array){ System.out.print("["); for (int i = 0;i < array.length ;i++){ if (i == array.length - 1){ System.out.println(array[i] + "]"); }else { System.out.print(array[i] + ", "); } } } //逆序1: arr.length / 2 public static void reverse(int[] arr){ for (int i = 0;i < arr.length / 2; i++){ //确定中间值 int temp = arr[arr.length - 1 -i]; //借助中间变量交换值 arr[arr.length - 1 -i] = arr[i]; arr[i] = temp; } } }
-
-
第二种
public static void reserve2(int[] arr){ for (int start = 0,end = arr.length - 1;start < end;start++, end--){ int temp = arr[end]; arr[end] = arr[start]; arr[start] = temp; } }
* 两次逆序又回到原数组
-
数组中的基本元素查找法: 查询元素 的第一次出现的索引值,每次都需要从头查到尾
-
对于基本元素查找法的----数组的元素的内容,可以无序/可以有序
/* 需求: * 已知一个数组,静态初始化了,查询数组中某个元素的索引值; * * int[] arr = {69,57,13,24,87} ; //查询13这个元素第一次出现的索引值 * //133元素 */ public class ArrayDemo3 { public static void main(String[] args) { //已知这个数组: int[] arr = {69,57,13,24,87} ; //调用方法 int index = getIndex(arr, 13);//找13 System.out.println("index:"+index); System.out.println("----------------------------") ; int index2 = getIndex(arr, 133);//找13 System.out.println("index2:"+index2); System.out.println("-----------------------------") ; //调用 int index3 = getIndex2(arr, 255); System.out.println("index3:"+index3); System.out.println("------------------------------"); int index4 = getIndex2(arr, 87) ; System.out.println("index4:"+index4); } //方法1: public static int getIndex(int[] array,int target){//array:传递一个数组,target:查询目标元素 //遍历数组,获取所有元素 for(int x = 0 ; x < array.length; x++){ //array[x]:每一个元素就可以获取到 //如果array[x] 和target 相等,就找到了,x返回 if(target == array[x]){//考虑找到的情况 return x ; } } //查询数组:找不到元素,返回负数 -1 return -1 ; } //方式2:假设思想 public static int getIndex2(int[] array,int target){ //1)先定一个变量index:表示索引值 int index = -1 ; //假设角标找不到 //2)遍历数组array for(int x = 0 ; x <array.length ; x ++){ //获取到每一个元素array[x] //如果 target == array[x]:找到了, if(target==array[x]){ //将index修改 index = x ; break ; } } return index ; } }
-
-
高级查询:二分搜索法(称为"折半查找):前提条件:数组的元素必须有序!
- 特点:能够节省查询时间,效率高
3.排序算法之冒泡排序
- 冒泡排序
- 两两相互比较,将较大的值往后边放,第一次比较完毕,最大值出现在最大索引处;
- 依次这样比较,可以得到排序好的数组;
- 规律
- 两两比较,将较大的值往后放,
- 第一次有0个不比
- 第二次有1个不比
- …
- 每次比较,就会减少一次比较 arr.length - 1 - x //x为比较的轮数,比较一轮少一人
- 比较的次数:数组长度-1次 arr.length - 1
public class BubbleSort {
public static void main(String[] args) {
//静态初始化数组
int[] arr = {16,34,56,39,96,64,56,58,78,86,98,89,87};
System.out.println("冒泡排序前的数组:");
printArray(arr);
System.out.println("-------------------------------");
System.out.println("冒泡排序后的数组:");
bubbleSort(arr);
printArray(arr);
}
//遍历方法
public static void printArray(int[] array){
System.out.print("[");
for (int i = 0;i < array.length ;i++){
if (i == array.length - 1){
System.out.println(array[i] + "]");
}else {
System.out.print(array[i] + ", ");
}
}
}
//冒泡排序
//每次比较,就会减少一次比较 arr.length - 1 - x //x为比较的轮数,比较一轮少一人
//比较的次数:数组长度-1次 arr.length - 1
public static void bubbleSort(int[] arr){
for (int x = 0; x < arr.length - 1; x++){//比较的次数:数组长度-1次 arr.length - 1
for (int y = 0; y < arr.length - 1 - x; y++){//每次比较,就会减少一次比较 arr.length - 1 - x
if (arr[y] > arr[y + 1]){
int temp = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = temp;
}
}
}
}
}
三.面向对象
1.面向对象(OO,Object Oriented)
-
面向对象是软件工程中的一类编程风格,很多人称之为开发范式,而面向对象正是众多开发范式中的一种.在所有开发范式中,我们接触最多的还是面向过程与面向对象这两种.
-
面向过程的程序设计(POP,Procedure Oriented Programming)
- 一过程为中心的编程思想,其实自顶而下的编程模式,最典型的就是C语言
- 在面向过程(PO,Procedure Oriented)的开发范式中,需要把问题分成一个个步骤,每个步骤用函数实现,再依次进行调用
-
面向对象编程实现(OOP,Object Oriented Programming)
- 在面向对象的开发范式在,将问题分解成一个个步骤,对步骤进行相应的抽象,从而形成对象,最终通过不同对象之间的调用来进行组合解决问题
-
2.类和对象
-
类: 是能够描述现实世界事物一组属性和行为的集合
- 类和事物的关系:一一对应的关系
- 类和事物的关系:一一对应的关系
-
对象: 是类中所表示事物中的一个个个体,如:定义一个动物类,像大象、老虎、长颈鹿、狮子、狗等动物就是其中的一个个对象
注意:
类中的成员变量:在类中方法外定义的变量
类中的成员方法: 和这几天写的方法 定义学生的方法
public 返回值类型 方法名(参数类型1 变量名1,...){ //业务逻辑 return 结果; } public void 方法名(参数类型1 变量名1,...){ //业务逻辑 直接输出 }
-
举例
//学生类:来描述现实世界真实的学生事物 public class Student { //成员变量:类中方法外 String name ; // 学生事物的属性 ----姓名 String gender ;//性别 int age ; //年龄 //学生的行为: 主要目的学习... public void study(){ System.out.println("Good Good Study ,Day Day Up"); } } -
补充:
- 基本类型作为形式参数和引用类型(数组,类,接口)作为形式参数的特点
- 基本类型作为形式参数:形参的改变不会实际参数;
- 引用作为形式参数:形式参数的改变直接影响直接实际参数,除String类
- 局部变量:生命周期:随着方法调用而存在,随着方法调用结束而结束;
- String作为形式参数(引用类型),和基本类型作为形式参数是一样,形式参数的改变不会影响实际参数;
- 基本类型作为形式参数和引用类型(数组,类,接口)作为形式参数的特点
3.测试类
- 里面是主方法main
- 代码中体现创建这个类对象 :创建具体的对象的格式
- 类名 对象名 = new 类名();
- 对象名.成员变量名 = 赋值;//成员变量赋值
- 对象名.成员方法名(); //调用成员方法
- 代码中体现创建这个类对象 :创建具体的对象的格式
public class PetTest {
public static void main(String[] args) {
Pet pet = new Pet(); //创建具体的对象
//成员变量赋值
pet.name = "团子";
pet.age = 6;
pet.color = "灰白相间";
pet.varieties = "哈士奇,俗称二哈";
//调用成员方法
pet.show();
pet.function();
}
}
4.封装
-
将公共对象私有化(加入一个关键字private),只能在当前类访问,对外数据的安全性!(外界不能访问的),通过封装对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX()),来从外界访问
-
private关键字的特点
-
被private修饰的成员变量和成员方法,只能在本类中进行访问 -
private可以修饰成员变量也可以成员方法,目的就是为了外界不能去直接访问 -
被private修饰的成员变量或者成员方法,可以间接的通过公共的方法来访问;
-
-
举例
//定义类 public class User { private String userName; private String name; private int age; private String sex; private String professional; //设置公共类,供外界录入和输出 public void setUserName(String userName) { this.userName = userName; } public String getUserName() { return userName; } public String getName() { if (userName.equals("admin")){ //权限设置 return name; }else { return "无权限"; } } public void setName(String name) { this.name = name; } public int getAge() { if (userName.equals("admin")){ return age; }else { return -1; } } public void setAge(int age) { this.age = age; } public String getSex() { if (userName.equals("admin")){ return sex; }else { return "无权限"; } } public void setSex(String sex) { this.sex = sex; } public String getProfessional() { if (userName.equals("admin")){ return professional; }else { return "无权限"; } } public void setProfessional(String professional) { this.professional = professional; } } //测试类 import java.util.Scanner; public class UserTest { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入管理员姓名:"); String userName = scanner.next(); User user = new User(); user.setUserName(userName); user.setName("一叶知秋"); user.setAge(28); user.setSex("男"); user.setProfessional("战士"); System.out.println(user.getName()); System.out.println(user.getAge()); System.out.println(user.getSex()); System.out.println(user.getProfessional()); } }
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
