JAVA笔记-面向对象

面向对象 对象的声明与创建

public static void main(String[] args) {	
	Cat mao = new Cat;
	mao.name = "小白"；
	mao.age = 5;
System.out.println("第一只猫的信息"+"姓名:"+mao.name+"年龄"+mao.age);
}

class Cat{
	String name;
	int age;
}

先定义一个Cat类

在类里面创建两个属性

再到main方法里面声明一个mao对象

调用Cat类里面的属性并赋值

最后输出

细节：

属性是类的一部分

属性的定义类型可以是任意类型，包含基本和引用类型

属性如果不赋值，有默认值

成员方法

方法的定义

访问修饰符 返回数据类型 方法名(形参列表) {
语句;
return 返回值;
}

方法带来的好处

1. 提高代码复用性
2. 2.可以将实现的细节封装起来,然后供其他用户来调用即可

public static void main(String[] args) {		
	Cat mao = new Cat;
	mao.a1();
	mao.getSum(10,20);
}

class Cat{
    public void a1(){
        System.out.println("我是一个好人");
    }
    public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
}

先定义一个Cat类

在类里面写两个方法a1和getSum

再到main方法里面声明一个mao对象

调用Cat类里面的方法

方法使用细节
访问修饰符(作用是控制 方法使用的范围) 如果不写就是默认

返回类型

1.一个方法最多有一个返回值，如果要返回多个结果可以返回数组

2.返回类型可以是任意类型，包含基本类型和引用类型(数组 对象)

3.如果方法要求有返回数据类型，则方法体中最后执行的语句必须return 值：
而且要求返回值类型必须和return的值类型一致或兼容

4.如果方法是void 则方法体中可以没有return语句，或者只写return不带返回值

方法名

遵循驼峰命名法,最好见名之一,表达出该功能的意思

形参列表

1.一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开

2.参数类型可以为任意类型，包含基本类型或引用类型

3.调用带参的方法时，一定对应着参数列表传入想同类型或兼容类型

4.方法定义时的参数称为形式参数，简称形参
方法调用时的参数称为实际参数，简称实参
实参和形参的类型要一致或兼容，个数，顺序必须一致

方法体

里面写完成功能的具体语句，

可以为输入，输出，变量，运算，分支，循环，方法调用

但里面不能再定义方法，即:方法不能嵌套定义

方法的调用

public static void main(String[] args) {			
	A a = new A();
		a.sayOk();
		a.mi();	
}
class A{
	public void print(int n) {
		System.out.println("print()方法被调用 n="+n);
	}
	public void sayOk() {
		print(10);
		System.out.println("继续执行SayOk");
	}
	public void mi() {
		B b = new B();
		b.hi();
	}
}
class B{
	public void hi(){
		System.out.println("B类中的hi被执行");
	}
}

解读

首先main主方法里面声明A类对象，调用A类下的sayOk方法和mi方法

然后写两个类一个A类一个B类

A类里面写三个方法

第一个方法 print 输出 (print()方法被调用 n="+n)

第二个方法sayOk ，先调用 print 方法并传入一个值10 ，最后输出 (继续执行SayOk)

第三个方法mi 属于跨类调用要调用B类的方法 ，创建B对象，然后在调用方法

B类里面写一个方法，hi专门给A类 mi 方法跨类调用

跨类方法调用就是在一个类的方法里面声明另一类个对象，然后调用另一个类的方法

总结

可能有点绕，一直调用来调用去

同一个类中的方法可以直接调用

o(￣▽￣)ｄ

方法传参机制

基本数据类型

public static void main(String[] args) {
	int a = 10;
	int b = 20;
    Al al = new Al();
    al.swap(a,b);
    System.out.println("main方法:"+"a="+a+"\tb="+b);
}

class Al{
    public void swap(int a,int b){
        System.out.println("swap方法交前:"+"a="+a+"\tb="+b);
        int tmp = a;
        a = b;
        b = tmp;
       System.out.println("swap方法交换后:"+"a="+a+"\tb="+b);
    }
}

运行流程

先把a，b的值传入swap方法里

第一次输出swap方法交前 a=10 b=20

进行a，b值交换

第二次输出swap方法交换后 a=20 b=10

回到main方法里

进第三次输出 a=10 b=20

总结

基本数据类型传的是值，把main方法的值拷贝到swap方法
所以swap方法的值进行交换，并不会改变main方法的值

引用数据类型

public static void main(String[] args) {
	int[] arr = {1,2,3};
    	Al al = new Al();
    	al.swap(arr);
    System.out.println("\nmain方法:");
		for(int i = 0;i<arr.length;i++) {
			System.out.print(arr[i]+"\t");
		}
}

class Al{
    public void swap(int[] arr){
        System.out.println("swap方法:");
        arr[0] = 100;
        for(int i = 0;i<arr.length;i++) {
			System.out.print(arr[i]+"\t");
		}
    }
}

运行流程

先调用swap方法，把arr的元素传进去

进入到swap方法，修改arr数组下标为 [0] 的元素，改成100

遍历arr数组，并输出

swap方法的结果 200 2 3

然后回到main方法，在进行一次遍历输出

main方法的结果 200 2 3

总结

引用数据类型传的是地址，不是值，所以main和swap方法同时指向一个地址
swap方法改变了地址里面的元素，main方法也会变

递归

递归重要规则:
1.执行方法时，就创建一个受保护的独立空间(栈空间)
2.方法的局部变量是独立的，不会相互影响
3.如果方法中使用的是引用类型变量(比如数组)，就会共享改引用类型的数据
4.递归必须向退出的条件逼近，否则就是无限递归，出现(StackOverflowError,死龟了)
5.当一个方法执行完毕，或者遇到return,就会返回，遵守谁调用,就将结果返回给谁,同时
当方法执行完毕或者返回时，该方法也就执行完毕

T t = new T();
		t.test(4);
		int res = t.factoria(5);
		System.out.println(res);

class T{
	//打印问题
	public void test(int n) {
		if(n>2) {
			test(n-1);
		}
		System.out.println("n="+n);
	}
	//阶乘问题
	public int factoria(int n) {
		if(n==1) {
			return 1;
		}else {
			return factoria(n-1)*n;//factoria(n-1)+n;n=100是执行从1加到100
		}
	}
}

总结

<(▰˘◡˘▰)> ╮(￣▽￣)╭