java基础的详细了解第二天

目录

• 1、方法的基本定义
• 2、方法重载
• 3、方法的递归调用
• 4、面向对象的前身是面向过程
• 5、类与对象
• 内存分析
• 引用传递
• 总结

1、方法的基本定义

限制条件：本次所讲解的方法指的是在主类中定义，并且由主方法由主方法直接调用。

方法是指就是一段可以被重复调用的代码块。 在java里面如果想要进行方法的定义，则可以使用如下的方法进行完成。

public static 方法返回值 方法名称（[参数类型 变量，....]）{
    方法体代码 ; 
     return [返回值];
}

在定义方法的时候对于方法的返回值由以下两类：void没用返回值和数据类型（基本类型、引用类型）。

public class TestDemo{
   public static void main(String args[]){
   //如果要在主方法里面调用该方法，该方法一定要用static进行修饰
   	print();	//主方法里面直接调用
   	print();	//主方法里面直接调用
   	print();	//主方法里面直接调用
   }
   public static void print(){
   	System.out.println("Hello,World!");
   }
}

但是有一点要特别的注意就是当返回值为void类型的时候，那么该方法当中可以直接使用return来直接结束调用。在一般情况下和if判断使用。

public class TestDemo{
	public static void main(String args[]){
	//如果要在主方法里面调用该方法，该方法一定要用static进行修饰
		print1(10);	//主方法里面直接调用
		print1(20);	//主方法里面直接调用
		print1(30);	//主方法里面直接调用
	}
	public static void print(){
		System.out.println("Hello,World!");
	}
	public static void print1(int x){
		if(x == 20){	//表示方法结束的判断
			return ;	//此语句之后的代码不在执行
		}
		System.out.println("x = " + x);
	}
}

2、方法重载

方法的重载是指：方法名称相同，参数的类型或个数不同。

public class TestDemo2{
	public static void main(String args[]){
	//如果要在主方法里面调用该方法，该方法一定要用static进行修饰
		System.out.println(add(10,20));	//主方法里面直接调用
		System.out.println(add(10,20,30));	//主方法里面直接调用
		System.out.println(add(10.1,20.1));	//主方法里面直接调用
	}
	public static int add(int a,int b){
		return  a + b;
	}
	public static int add(int a,int b,int c){
		return a + b + c;
	}
	public static double add(double a, double b){
		return a + b;
	}
}

在方法重载的时候有一个重要的原则就是要求方法的返回值类型一定要相同。

通过用System.out.println()输出发现所有的类型都可以进行输出，由此我们可以发现这个方法是一个重载的方法。

3、方法的递归调用

方法的递归调用指的是一个方法调用自己的形式。如果要进行方法的递归操作往往都具备以下特点

方法必须有一个递归的结束条件

方法在每次递归处理的时候一定要做出一些变更

计算60！

public class TestDemo4{
	public static void main(String args[]){
		System.out.println(mul(60));	
	}
	public static double mul(double num){
		if (num == 1){
			return 1;
		}
		return num * mul(num - 1);
	}
}

计算结果：

8.320987112741392E81

其实我们在使用while的循环操作大部分都可以使用递归，而使用递归是因为主要一个方法可以执行的操作很多，而且结构简单、好。

4、面向对象的前身是面向过程

两者的区别：笼统的将最好的例子就是面向过程是解决问题，面向对象是模块化设计。对于现在的程序就像是汽车组装，不同的工厂生产不同零件，将这些零件组装在一起可以形成一个汽车，当我们零件坏了的时候还可以进行配装。

面向对象在实际上还有很多的特点

• 封装性：内部的操作对外部而言是不可见的。
• 继承性：在上一辈的基础上继续发展。
• 多态性：这是我们最为重要的一个环节，利用多态性才可以得到良好设计。

三个阶段：OOA(面向对象分析)、OOD(面向对象设计)、OOP(面向对象编程) 专业化术语

5、类与对象

类和对象是面向对象核心所在，也是所有概念的基础。类属于我们的引用类型，所以类的使用会牵扯到我们的内存分配问题

所谓的类就是一个共性的概念，而对象就是一个具体可以使用的事物。

类的组成：方法（操作行为）、属性（变量，描述每一个对象的具体特点）。

类的定义一般有class进行声明

class 类名称{
	属性1;	//属性可以是多个
    属性2；
}

此时的方法不在由主类进行调用，而是要通过对象进行调用。

声明实例化对象

class Person{	//定义一个类首先要将类的名称每个首字母进行大写
	public void info(){
		System.out.println("name = "+ name + "\nage = " + age);
	}
}
public class TestDemo5{
	public static void main(String args[]){
		//实例化对象第一种方式
		Person person = new Person();
		person.name = "张三";	//设置对象中的属性值
		person.age = 13;	//设置对象中的属性值
		person.info();
		//实例化对象第二种方式
		Person person1 = null;
		person1 = new Person();
		person1.info();
	}	
}

引用数据类型最大的特征在于内存的分配操作，只要出现关键字new那么只有一个解释：开辟新的内存（内存是不可能无限开辟的，所以这个时候所谓的性能调优调整的就是内存问题）。

内存分析

我们使用的内存空间分为两块：堆内存空间（保存真正的数据，保存对象的属性信息）和栈内存空间（保存的堆内存的地址，堆内存操作权，简单理解叫保存对象的名称），所有数据类型必须在开辟空间后才能使用。如果使用了未开辟的数据类型则会出现NullPointerException，只有引用数据类型（数组、类、接口）才会产生此类异常，以后出现了根据错误位置观察其是否进行实例化对象。

引用传递

引用传递的本质就在于别名，而这个别名只不过是放在我们栈内存当中，一块堆内存可以被多个栈内存所指向。

class Person{	//定义一个类首先要将类的名称每个首字母进行大写
	String name;
	int age;
	public void info(){
		System.out.println("name = "+ name + "\nage = " + age);
	}
}
public class TestDemo5{
	public static void main(String args[]){
		//实例化对象第一种方式
		Person per = new Person();
		per.name = "张三";	//设置对象中的属性值
		per.age = 13;	//设置对象中的属性值
		per.info();
		//实例化对象第二种方式
		Person per1 = null;
		per1 = new Person();
		per1.name = "小于子";
		per1.age = 30;
		per1.info();
		//此步骤就是引用传递的操作
		Person per2 = per1;
		per2.name = "狗剩";
		per1.info();
	}	
}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注脚本之家的更多内容！