1.方法
方法就是完成特定功能的代码块
方法分为：方法重载与方法覆盖
方法重载（overloading method)
方法重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数不相同。参数不同具体体现在参数的个数不同或者参数的类型不同
方法覆盖 （overriding method）
方法覆盖又称为方法重写，是指子类的方法名与父类的方法名完全的相同（即有一模一样的方法声明），并且返回值的类型。入口参数的数目，类型均相同，即在子类中重新改写了父类中的同名方法。
方法重写的应用：
在子类要使用父类的功能的时候，而主题子类有自己特有的内容时，可以重写父类中的方法。这样既沿用了父类中的功能，还定义了子类特有的内容。
方法重写的注意事项：
1.父类中的私有方法不能被重写；（即父类中的私有方法子类不能继承）
2.父类为静态方法，子类也必须要通过静态方法来进行重写；
3.子类重写父类方法时，子类的访问权限不能比父类的访问权限低；
4.子类在重写父类的方法时，应该保持方法声明一样；
方法的格式:
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
方法体;
return 返回值;
}
方法的注意事项：
- 方法不调用不执行
- 方法与方法是平级关系，不能嵌套定义
- 方法定义的时候参数之间用逗号隔开
- 方法调用的时候不用在传递数据类型
- 如果方法有明确的返回值，一定要由return带回一个明确的结果。
例如：
用方法调用输出
*
**
***
****
*****
package com.baidu.demo;
import java.util.Scanner;
public class Mytest{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入行数");
int num= scanner.nextInt();
System.out.println("请输入列数");
int num2 = scanner.nextInt();
showStar(num,num2);
}
private static void showStar(int num, int num2) {
for (int i = 0; i <= num; i++) {
for (int j = 0; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
构造方法
作用：
创建对象,给对象中的成员进行初始化
格式特点：
1.方法名与类名相同
2.没有返回值，连void都没有
3.没有具体的返回值
注意事项：
如果没有给出构造方法，系统会自动提供一个无参构造方法
如果给出了构造方法，系统将不再提供默认的无参构造方法
如果此时还想使用无参构造方法，就需要自己给出，一般建议是自己给出构造方法
2.数组
数组是储存在同一种数据类型的多个元素的集合,既可以储存基本数据类型也可以储存引用数据类型。用下标来表示同一数组中的不同数组元素，使用时可以通过数组名和下标访问数组中的元素。其下标从0开始
数组的特点：
- 一个数组中的元素数据类型应该是相同的。
- 数组中的各个元素是有序的，它们在内存中按照先后顺序连续存放在一起。
- 每个数组元素用其所在的名字和数组下标来确定。
- 数组的下标从0开始，数组的长度是指其所包含的数组的个数。
一维数组
声明数组包括数组的名字、数组包含的元素的数据类型。
1.声明一维数组的格式：
数组元素类型[] 数组名；//格式1
数组元素类型 数组名[]; //格式2
例如：
double [] score;
double score [];
2.数组的创建
为数组分配内存的格式如下：
数组名=new数组元素的类[数组的长度]；
score = new double [2];
内存分配：
栈：储存的都是局部变量
局部变量是指方法定义中或方发声明上的变量
堆：每一个new出来的东西
系统会为每一个new出来的东西分配一个内存地址值
每一个元素都有默认的初始化值。
方法区：面向对象的部分。
3.数组的初始化
数组创建后如果不对其进行初始化，系统会根据其类型自动为元素赋值，如果数组的元素是基本类型的元素，数组中元素默认初始化的值是基本类型的默认值。（就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。）
数据基本类型的数组元素的默认值
| 数据类型 | 默认值 | 数据类型 | 默认值 |
|---|---|---|---|
| byte | 0 | char | \u0000 |
| int | 0 | float | 0.0 |
| short | 0 | double | 0.0 |
| long | 0 | boolean | false |
数组的初始化分为：静态初始化，动态初始化。
这两种方式每次只能使用一种，不能动静结合使用。
1.静态初始化：
只给定初始化值，由系统决定长度。
数据类型 [] 数组名 = new 数据类型 [] {元素1，元素2,......}；
例如：
double [] arr = new double [] {34,54,345,78};
静态初始化图解：
2.动态初始化：
只给定长度，由系统给出初始化值。
数据类型 arr [] = new 数据类型 [];
例如：
double arr[] = new double [5];
动态初始化图解：
4.数组的使用
1.数组的遍历
1.所有的数组都有一个属性length（长度），储存了数组元素的个数。例如：score.length 指的是数组score的长度。
2.所谓的数组遍历是指依次输出数组中的每个元素，数组遍历有正向遍历与反向遍历。
例如：
package com.baidu.demo;
public class shuzudemo {
public static void main(String[] args) {
int [] arr =new int[] {23,21,45,55};
//正向遍历
for (int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
System.out.println(".................");
//反向遍历
for (int i = arr.length-1; i >=0; i--) {
System.out.println(arr[i]);
}
}
}
结果为：
23
21
45
55
.................
55
45
21
23
2.数组获取最值
就是利用数组的长度length，对数组中的元素进行循环比较取最大最小值；
例如：
package com.baidu.demo;
public class shuzubijiaodemo {
public static void main(String[] args) {
int []arr = new int []{45,65,232,12,478};
int max=getmax(arr);
int min = getmin(arr);
System.out.println(max);
System.out.println(min);
}
public static int getmax(int [] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
public static int getmin(int [] arr) {
int min =arr[1];
for (int i = 1; i <arr.length; i++) {
if (arr[i]<min){
min = arr[i];
}
}
return min;
}}
结果为：
478
12
3.数组的反转
就是将数组中的元素顺序倒排列
例1：
package com.baidu.demo;
public class szfzdemo {
public static void main(String[] args) {
int []arr =new int []{10,45,626,98,1};
for (int i = 0, j= arr.length-1;i<j ; i++,j--) {
int d=arr[i];
arr[i]=arr[j];
arr[j]=d;
}
showarr(arr);
}
private static void showarr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]+"\t");
}
}
}
结果：
1
98
626
45
10
2.先遍历后反转：
package com.baidu.demo;
public class Demo {
public static void main(String[] args) {
//数组元素反转(就是把元素对调)
int[] arr = {10, 20, 30, 40, 50}; //50 40 30 20 10
reverseArray(arr);
showArray(arr);
}
// 数组元素反转
private static void reverseArray(int[] arr) {
//分析：首尾元素值交换，遍历一半
for (int i = 0; i < arr.length / 2; i++) {
//采用中间变量进行值交换
int t = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = t;
}
}
private static void showArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + ",");
}
}
}
结果：
50,40,30,20,10,
二维数组
二维数组可以看成是一个特殊的一维数组，其每一个元素均是一个一维数组。（就是数组嵌套数组）
1.二维数组的格式
数据类型[][] 变量名 = new 数据类型[m][n];
m指的是二维数组里面有m个一维数组。
n指的是每一个一维数组里面有n个元素。
注意：m必须写，n 可写可不写
例如：
int[][] arr = new int[3][2];
int[][] arr = new int[3][];
int a [][] = new int [3][2];
int [] a [] = new int [3][2];
第一个数（3）指的是二维数组里面有三个一维数组，后面的数（2）指的是每一个一维数组里面有2个元素。
2.二维数组的初始化
- 用new关键词初始化
数组名 = new 数组元素的类型 [数组的行数] [数组的列数]；
- 用赋初值的方法初始化
类型 数组名[] [] = {{初值表1}，{初值表2}，{初值表3}，{初值表4}}；
3.二维数组的使用
用二维数组写出杨辉三角
package 第一章;
//利用二维数组打印杨辉三角
import java.util.Scanner;
public class Triggle2 {
public static int[][] value(int n){
int[][] trg=new int[n][];
for(int i=0;i<trg.length;i++) {
trg[i]=new int[i+1];
trg[i][0]=1;
trg[i][i]=1;
}
for(int i=2;i<n;i++) {
for(int j=1;j<i;j++) {
trg[i][j]=trg[i-1][j]+trg[i-1][j-1];
}
}
return trg;
}
public static void print(int[][] trg,int n ) {//打印二位数组
int k;//用来打印空格的变量
for(int i=0;i<trg.length;i++) {
for(k=n-i-1;k>0;k--) {
System.out.print(" ");
}
for(int j=0;j<i+1;j++) {
System.out.print(trg[i][j]+" ");
}
System.out.println("\n");
}
}
public static void main(String[] args) {
System.out.println("请输入杨辉三角的行数");
Scanner sca=new Scanner(System.in);
int n=sca.nextInt();
print(value(n), n);
}
}
请输入杨辉三角的行数
5
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
4895
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
