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