Java学习笔记（二）

目录

定义一个无参数和有参数的方法：

方法的重载（overload）：

构成重载的条件：

不构成方法重载：

递归结构：

递归注意事项：

 

面向过程和面向对象：

 

---

---

定义一个无参数和有参数的方法：

public class Method {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//通过对象来调普通方法， 对象怎么来的？--> Method就是对象。
		Method bbb = new Method();         
		bbb.print();
		bbb.print();    //方法的好处是可以被我们反复的调用
		
	}
		//定义一个无参数的方法
		void print() {
			System.out.println("hahahah");
			System.out.println("haah");
			System.out.println("ha");
	}	
}
-----------------------------------------------------------------------------------------
public class Method {
	
	public static void main(String[] args) {
	// TODO Auto-generated method stub

		Method bbb= new Method();
		bbb.add(30,40,50);		
        //如果要调用的话要传实参，调的时候依次赋给a,b,c，然后再执行方法里面的代码
	}
		//定义一个有参数的方法
		
		void add(int a ,int b,int c) {        // a,b,c就是我们的形参
			int sum=a+b+c;
			System.out.println(sum);
		}
		int add(int a ,int b,int c) {        
			int sum=a+b+c;
			System.out.println(sum);
			return sum;    //return两个作用，1.结束方法的运行，2.返回值
}

• 方法的重载（overload）：

在一个类里面有多个方法的名称相同，例如在班上有两个人的名字都叫王小明，但实际上是两个不同的人。实际上是完全不同的人，只是名称相同而已。

构成重载的条件：

普通方法的重载：方法名相同，在同一个类中。参数类型，顺序，个数不同，构成重载。

1.不同含义：形参类型，形参个数，形参顺序不同（即调用的时候是可以区分的）

2.只有返回值不同不构成方法的重载

加个static是为了方便调用，当调用非static的方法，必须要new一个对象，如果加了static，就不用new一个对象，可以直接调用。

public class Overload {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(add(1,2));
		System.out.println(add(1,2,3));  
		System.out.println(add(3.0,5));    //不会出现不知道调用哪一个
		System.out.println(add(5,3.0));  
	}
	
//加个static是为了方便调用，当调用非static的方法，必须要new一个对象，如果加了static，就不用new一个对象，可以直接调用。
	//  1.
	public static int add(int n1,int n2) {
	int sum=n1+n2;
	return sum;
	}
	
	//   2.   方法名不同，参数个数不同，构成重载
	public static int add(int n1,int n2,int n3) {
	int sum=n1+n2+n3;
	return sum;
	}
	
	//	 3.   方法名相同，参数类型不同，构成重载
	public static double add(double n1,double n2) {
	double sum=n1+n2;
	return sum;
	}
	
	//    4.  方法名相同，参数顺序不同，构成重载
	public static double add(int n1,double n2) {
	double sum=n1+n2;
	return sum;
	}
}

不构成方法重载：

• 	//  1.
  	public static int add(int n1,int n2) {
  	int sum=n1+n2;
  	return sum;
  	}
  
  	//不构成方法重载情况：
  
  	//编译错误：只有返回值不同，不构成方法重载。
  	public static double add(int n1,int n2) {
  	int sum=n1+n2;							//与第一个相冲突，系统不知道调用哪一个
  	return sum;
  	}
  
      //编译错误：只有参数名称不同，不构成方法的重载。
  	public static int add(int n2,int n1) {
  	int sum=n1+n2;							//与第一个相冲突，系统不知道调用哪一个
  	return sum;
  	}

构造方法的重载： 

public class UserConstructorOverload {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		UserConstructorOverload u1=new UserConstructorOverload();
		UserConstructorOverload u2=new UserConstructorOverload(01,"chen");
		UserConstructorOverload u3=new UserConstructorOverload(02,"chen","chen123");
		}

	int id;
	String name;
	String pwd;
	
	public UserConstructorOverload() {
		
}
	public UserConstructorOverload(int id, String name) {
		this.id=id;
		this.name=name;
	}
	
	public UserConstructorOverload(int id, String name, String pwd) {
		this.id=id;
		this.name=name;
		this.pwd=pwd;
	}
	
}

递归结构：

递归的基本思想就是”自己调用自己”。

在进行递归的时候必须定义递归头和递归体
                       递归头：里面必须有一个地方，告诉递归什么时候结束，什么时候不掉用自身方法，如果没有头，将陷入死循环
                       递归体：什么时候需要调用自身方法    

public class Recursion {
	public static void main(String[] args) {
		A();
	}
	
	static void B() {
		System.out.println("b");
	}
	
	static void A() {
		System.out.println("a");
		B();            //      A里面调用B
		A();	        /*      调用自己，循环反复的调用自己，直到异常
      就是A(A(A(A(A.....     A打开了，还没有关闭，就又调用了A，直到你占满了系统的资源，跑出异常   	
		 		         */
	}
	

	//正确-->
	static int count=0;     //static也要加 
	static void A() {
		System.out.println("a");
		if(count<10) {         //递归体
			A();
		}else {                //递归头
			return;
		}
		
	}
}

递归练习：计算n!

//计算n!:  1*2*3*4*5*....*n
public class 递归_计算阶乘 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		System.out.print("%d阶乘的结果：%s%n",10,factorial(10));      //有static可以直接调用
	}
	
	 static long factorial(int n) {
		if(n==1) {
			return 1;
		}else {
			return n*factorial(n-1);
		}
	}
	
	}

注意：System.out.print("%d阶乘的结果：%s%n",10,factorial(10)); 

递归注意事项：

1. 任何能够递归解决的问题也能使用迭代解决，当递归方法可以更加自然的反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归。

2. 在要求高性能的情况下尽量避免使用递归，递归调用即花时间又耗内存。