Java基础学习day9
理解“万事万物皆对象”
-
在Java语言范畴中,我们都将功能、结构等封装到类中,通过类的实例化,来调用具体的功能结构
Scanner,String等
文件:Fi1e
网铬资源:URL -
涉及到JaVa语言与前端utm、后端的数据库交互时,前后端的结构在JaVa层面交互时,都体现为类、对象。
匿名对象的使用
- 理解:我们创建的对象,没有显式的赋给一个变量名。即为匿名对象\
- 特征:匿名对象只能调用一次。
封装数组工具类
utils类
public class ArrayUtils {
//求数组的最大
public int getMax(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
}
}
return max;
}
//求数组的最小
public int getMin(int[] array) {
int min = array[0];
for (int i = 1; i < array.length; i++) {
if (min > array[i]) {
min = array[i];
}
}
return min;
}
//求数组的总和
public int getSum(int[] array) {
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum = sum + array[i];
}
return sum;
}
//求数组的平均
public int getAvg(int[] array) {
int avg = getSum(array) / array.length;
return avg;
}
//反转数组
public void getReserve(int[] array) {
for (int i = 0; i < array.length/2; i++) {
int temp=array[i];
array[i] = array[array.length-1-i];
array[array.length-1-i]=temp;
}
}
//复制数组
public int[] getCopy(int[] array) {
int[] newArray = new int[array.length];
for (int i = 0; i < array.length; i++) {
newArray[i] = array[i];
}
return newArray;
}
//数组排序
public void sort(int[] array){
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-i; j++) {
if(array[j]>array[j+1]){
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
//遍历数组
public void toString(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+"\t");
}
System.out.println();
}
//查找指定元素
public int findIndex(int[] array,int a) {
for (int i = 0; i < array.length; i++) {
if(array[i]==a){
return i;
}
}
return -1;
}
}
测试类
public class ArrayTest {
public static void main(String[] args) {
int[] arr = new int[]{1,88,99,45,71,-21,7,-9,0};
ArrayUtils arrayUtils = new ArrayUtils();
arrayUtils.toString(arr);
System.out.println(arrayUtils.getMax(arr));
System.out.println(arrayUtils.getMin(arr));
System.out.println(arrayUtils.getAvg(arr));
System.out.println(arrayUtils.getSum(arr));
int[] copy = arrayUtils.getCopy(arr);
arrayUtils.toString(copy);
int index = arrayUtils.findIndex(arr, 7);
if(index>=0){
System.out.println("找到了,位置在:"+index);
}else {
System.out.println("找不到哦!!!!");
}
arrayUtils.getReserve(arr);
arrayUtils.toString(arr);
arrayUtils.sort(copy);
arrayUtils.toString(copy);
}
}
方法的重载
定义:在同一个类中,方法名相同,只要他们的参数个数、参数属性、参数属性顺序不同即可
记忆:两同一不同
类相同 方法名相同
参数列表不同:参数个数、参数属性
判断是否重载与方法权限修饰符、返回值类型、方法体、参数属性顺序以及形参变量名均无关系
在调用对象是如何调用一个指定的方法
方法名-----》形参列表
可变个输形参的方法
1.jdk5.0新增的内容
2具体使用:
2.1可变个数形参的格式:数据类型 …
变量名
2.2当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个,…
2.3可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载
2.4可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载。换句话说,二者不能共存
2.5可变个数形参在方法的形参中,必须声明在末尾
2.6可变个数形参在方法的形参中,最多只能声明一个可变形参。
关于变量的赋值:
值传递机制
如果变量是基本数据类型,此时赋值的是变量所保存的数据值。
如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。
例:
public class Demo {
public static void main(String[] args) {
int m=10;
int n=20;
System.out.println("m="+m+"n="+n);
Demo demo = new Demo();
demo.swap(m,n);
System.out.println("m="+m+"n="+n);
}
public void swap(int m,int n){
int temp=m;
m=n;
n=temp;
}
}
结果为
出现的原因:
根本原因:局部变量在方法结束后就会自动销毁,此情况变量是基本数据类型,会直接调用数据的值
解决办法:
创建引用数据类型来辅助交换
方法一:创建一个类用类来存储
public class Demo {
public static void main(String[] args) {
int m=10;
int n=20;
System.out.println("m="+m+"n="+n);
Demo demo = new Demo();
Date date = new Date();
date.m=m;
date.n=n;
demo.swap(date);
System.out.println("m="+date.m+"n="+date.n);
}
public void swap(Date date){
int temp=date.m;
date.m=date.n;
date.n=temp;
}
}
class Date{
int m;
int n;
}
例二:
public class Demo1 {
public static void main(String[] args) {
int[] nums = new int[]{1,3,7,55,-9,-78};
Demo1 demo1 = new Demo1();
for (int i = 0; i < nums.length-1; i++) {
for (int j = 0; j < nums.length-1-i; j++) {
if(nums[j]>nums[j+1]){
demo1.swap(nums[j],nums[j+1] );
}
}
}
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i]+"\t");
}
}
public void swap(int m,int n){
int temp=m;
m=n;
n=temp;
}
}
错误原因:同理,数据类型为基本数据类型是存在栈内存中,相当于复制
解决方法:
public class Demo1 {
public static void main(String[] args) {
int[] nums = new int[]{1,3,7,55,-9,-78};
Demo1 demo1 = new Demo1();
for (int i = 0; i < nums.length-1; i++) {
for (int j = 0; j < nums.length-1-i; j++) {
if(nums[j]>nums[j+1]){
demo1.swap(nums,j,j+1);
}
}
}
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i]+"\t");
}
}
public void swap(int[] arr,int m,int n){
int temp=arr[m];
arr[m]=arr[n];
arr[n]=temp;
}
}
练习
代码:
Circle类
public class Circle {
double radius;
public double findArea(){
return Math.PI*radius*radius;
}
}
PassObject类
public class PassObject {
public void printAreas(Circle c,int time){
System.out.println("Radius"+"\t"+"\t"+"Area");
for (int i = 1; i < time+1; i++) {
c.radius=i;
System.out.println(c.radius+"\t"+"\t"+"\t"+c.findArea());
}
c.radius=time+1;
}
}
测试类
public class Demo3 {
public static void main(String[] args) {
PassObject passObject = new PassObject();
Circle circle = new Circle();
passObject.printAreas(circle,5);
System.out.println("now the radios is "+circle.radius);
}
}
递归方法
-
递归方法:一个方法体内调用它自身。
-
方法递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制
递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环。