二.函数(也叫方法)部分做重点记录：
1.示例：
class FunctionDemo{
public static void main(String[] args){
}
}
/*
函数的格式：
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2）
{
执行语句；
return 返回值；
}
返回值类型：函数运行后的结果的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return:用于结束函数。
返回值：该值会返回给调用者。
函数的特点：
·定义函数可以将功能代码进行封装
·便于对该功能进行复用
·函数只有被调用时才会被执行
·函数的出现提高了代码的复用性
·对于函数没有具体返回值的情况，返回值类型用关键字void表示，
那么该函数中的return语句如果在最后一行可以省略不写。
·注意：
*.函数中只能调用函数，不可以在函数内部定义函数。
*.定义函数时，函数的结果应该返回调用者，由其处理。
（1）<=>（2）都是调用了函数，两种情况是一样的。
（1） int x=getResult(4);
int w=getResult(6);
System.out.println("x="+x+",w="+w);
}
public static int getResult(int num){
return num*3+5;
}
*/
（2） getResult(8);
}
public static void getResult(int num){
System.out.println(num*3+5);
}
}
2.如何定义一个函数（即方法）？
（1）先明确该函数的运算结果，即明确函数的返回值类型。
（2）再明确函数的参数列表，即参数类型和参数个数。
举例演示：
需求：
定义一个功能，完成3+5的运算，并将结果返回给调用者。
思路：
如何定义一个函数：
1.先明确该函数的运算结果的类型（明确函数的返回类值类型）
2.明确在函数中参与运算的内容是否有未知（参数的类型和参数的个数）。
class FunctionDemo2{
public static void main(String[] args){
int sum=getSum(3,5);
System.out.println("sum="+sum);
}
public static int getSum(int x,int y){
return x+y;
}
}
以上代码可以化为：
class FunctionDemo2{
public static void main(String[] args){
getSum(3,5);
}
public static void getSum(int x,int y){
int sum =x+y;
System.out.println("sum="+sum);
}
}
需求:判断两个数是否相同。
思路：
1.明确功能的结果：结果是：boolean.
2.功能是否有未知内容参与运算。有，两个整数。
第一种方法：
class FunctionDemo2{
public static void main(String[] args){
boolean cp=compare(6,8);
System.out.println("cp="+cp);
}
public static boolean compare(int a,int b){
if(a==b)
return true;
else //该else可以省略
return false;
}
}
第二种方法：
class FunctionDemo2{
public static void main(String[] args){
boolean cp=compare(6,8);
System.out.println("cp="+cp);
}
public static boolean compare(int a,int b){
return a==b;// 三元运算
}
}
//三元运算（return(a==b)?true:false简写为return a==b;
需求：定义功能，对两个数进行比较，获取较大的数。
第一种： class FunctionDemo2{
public static void main(String[] args){
int max=getMax(6,9);
System.out.println("max="+max);
}
public static int getMax(int a,int b){
if(a>b)
return a;
else
return b;
}
}
第二种： class FunctionDemo2{
public static void main(String[] args){
int max=getMax(6,9);
System.out.println("max="+max);
}
public static int getMax(int a,int b){
return (a>b)?a:b;
}
}
下面这道题是一些基础的综合，也是为以后练习设计几个常用的功能函数做下伏笔。
/* 题：
----*
---* *
--* * *
-* * * *
* * * * *
(
不是规律的规律：
尖朝上，可以改变条件，让条件随着外循环变化
尖朝下，可以初始化值，让初始化值随着外循环变化。
)
*/
class ForForTest2{
public static void main(String[] args){
for(int x =0;x<5;x++)
{
for(int y =x+1;y<5;y++)
{
System.out.print("-");
}
for(int z =0;z<=x;z++)
{
System.out.print("* ");
}
System.out.println();//只是换行的功能
}
}
}
/*需求：定义一个功能，用于打印矩形。
思路：
1.确定结果：没有，因为直接打印，所以返回类型是void。
2。有未知内容吗？有，两个，矩形的行和列不确定。
（我们可以打印分割线作出多个矩形的间隔，可以把分割线也做
成函数）
class FunctionTest{
public static void main(String[] args){
draw(6,8);
printHr();
draw(5,6);
printHr();
}
public static void draw(int row,int col){
for(int x=0;x<row;x++){
for(int y=0;y<col;y++){
System.out.print("*");
}
System.out.println();
}
}
public static void printHr(){
System.out.printl("-----------------");
}
}
三。重载：
概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
特点：与返回值类型无关，只看参数列表。
好处：方便于阅读，优化了程序设计。
什么时候用重载：当定义的功能相同，但参与运算的未知内容不同，那么这时就定义一个函数名称以表示功能，方便阅读，而通
过参数列表的不同来区分多个同名函数。函数的功能一样，仅仅是参与运算的未知内容不同时，可以定义多函数，却使用统一函数名称，这样方便阅读。
示例：
返回两个整数的和
int add(int x,int y){return x+y;}
返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
返回两个小数的和
double add(double x,doubley){return x+y;}
*需求：定义一个打印九九乘法表式功能的函数，不仅仅局限于九九乘法，可以六六、八八等乘法。这里不仅用了调用函数对象，
也用了重载（令定义num,num则是灵活的数，那么本函数可以num的乘法表功能)
class FunctionTest
{
public static void main(String[] args)
{
print99(6);
print99(8);
}
public static void print99(int num){
for(int x=1;x<=num;x++){
for(int y=1;y<=x;y++){
System.out.print(x+"*"+y+"="+x*y+"\t");
}
System.out.println();
}
}
}
*定义一个加法运算，获取两个整数的和；获取两三个整数的和。
class FunctionOverload{
public static void main(String[] args){
int a=add(2,9);
System.out.println("a="+a);
int b=add(2,9,3);
System.out.println("b="+b);
}
public static int add(int x,int y){
//System.out.print("x+y="+(x+y)+"\n");
return x+y;
}
public static int add(int x,int y,int z){
//System.out.print("x+y+z="+(x+y+z)+"\t");
return x+y+z;
}
}
四。数组.
概念：数组就是同一种类型那个数据的集合，是一个容器，是引用类型，存储在堆中。
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];
格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
示例;int[] arr = new int[]{3,5,1,7};int[] arr = {3,5,1,7};
在内存结构中，java分了5片区域。（主要讲下栈和堆）
1：寄存器。2：本地方法区。3：方法区。4：栈内存。5：堆内存
栈内存：存储的都是局部变量(函数中定义的变量，函数上的参数
，语句中的变量);只要数据运算完成所在的区域结束，该数据就被释放。
堆内存：用于存储数组和对象，也就是实体,通过new建立。
1：每一个实体都有内存首地址值。
2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。
3：垃圾回收机制。
垃圾回收机制Garbage Collection
对象空间的分配：使用new关键字创建对象即可
对象空间的释放：将对象赋值null即可，垃圾回收器将负责回收所有“不可达”对象的内存空间。
要点：
* 程序员无权调用垃圾回收器
* 程序员可以通过System.gc()。通知GC运行，但是jAVA规范并不能保证立刻运行。
*finalize方法，是JAVA提供给程序员用来释放对象或资源的方法，但是尽量少用。
什么是垃圾？
对象无人使用了，就变成了垃圾。
数组代码示例：
需求：想定义一个可以存储3个整数的容器。
class ArrayDemo{
public static void main(String[] args){
int[] arr = new int[3];
arr[0] = 80; //名称为arr的数组，角标为0的位置。
//给该位置赋值为80.
System.out.println(arr[0]);//打印数组中角标为
//0的元素的值。
}
}
* 数据类型不同，结果不一样。
class ArrayDemo{
public static void main(String[] args){
int[] x = new int[3];
int[] y=x;
y[1]=78;
x[1]=66;
x=null;
System.out.println(y[1]);//此时y[1]=66.
}
}
|
|
收藏
淘帖
踩
