知识点(慢慢更新..break,continue，return 重载和重写的区别)-CSDN博客

break用于完全结束一个循环，跳出循环体，执行循环后面的语句。

使用场合主要是switch语句和循环结构。

● 在循环结构中使用break语句，如果执行了break语句，那么就退出循环.
 for (int i = 0; i < 10; i++) {
			if (i == 7) {
				break;
				// 在执行i==7时强制终止循环，i==7不会被执行
			}
			System.out.print(i + " ");
		}
●如果在多重嵌套循环中使用break语句，当执行break语句的时候，退出的是它所在的循环结构，对外层循环没有任何影响。
// 外循环，循环5次
		for (int i = 0; i < 5; i++) {
			System.out.print("第" + (i + 1) + "次循环：");
			// 内循环，设计为循环10次
			for (int j = 0; j < 10; j++) {
				// 判断j是否等于3，如果是，则终止循环
				if (j == 3) {
					break;
				}
				System.out.print("内循环的第" + (j + 1) + "次循环\t");
			}
			System.out.println();
		}
●如果循环结构里有switch语句，并且在switch语句中使用了break语句，当执行switch语句中的break语句时，仅退出switch语句，不会退出外面的循环结构
for (int i = 0; i < 10; i++) {
			System.out.print("第"+i+"次循环: ");
			switch (i) {
			case 7:
				System.out.print("跳出switch ");
				break;
			default:
				System.out.print("switch"+i + " ");
				break;
			}
			System.out.print("for循环"+i + " ");
			System.out.println();
		}

2. continue

终止当前循环，但是不跳出循环

//continue ---跳出本次循环 执行下一次循环
		for (int i = 0; i <=10; i++) {
			if ((i&1)==1) {
				continue;
			}
			System.out.print(i);//0246810
		}

●break和continue关键字，操作的是当前离他最近的循环

●操作外层循环，别名标识名字: --- 同变量名命名方法
//break和continue关键字，操作的是当前离他最近的循环，
		//操作外层循环，别名标识
		out:for (int i = 0; i < 10; i++) {
			inner:for (int j = 0; j < 10; j++) {
				if(j==3) {
					//break out;
					continue out;
				}
				System.out.print(i+"_"+j+"  ");
			}
			System.out.println();
		}

3. return

return语句可以使其从当前方法中退出，返回到调用该方法的语句处，继续程序的执行。

用法:

●在有返回值的方法中，返回方法指定类型的值，同时结束方法执行；

public static void main(String[] args) {
		System.out.println(test2());
		}
	  public static String test2(){
	        System.out.println("--有返回值类型的return语句测试--");
	        return "返回一个字符串";
	    }

●也可以用在返回值为void的方法中，用来终止方法运行；

比如主方法:

public class Demo01{
    public static void main(String[] args) {
        for (int i = 0;i < 10;i++){
            if (i == 5){
                return;
            }
            System.out.println(i);
        }
        System.out.println("stop");
    }
}

4. 总结

●return ：直接跳出当前的方法,返回到该调用的方法的语句处,继续执行

●break：在循环体内结束整个循环过程

●continue ：结束本次的循环，直接进行下一次的循环

二、重载和重写的区别

1. Overload 重载

在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，JavaOOP的语法允许把这一组方法名定义为同名方法。

●方法的重载:在同一个类中，方法名相同，参数项不同(类型，个数，顺序)

●和返回值无关,发生在编译期

//方法的重载:在同一个类中，方法相同，参数项不同(类型，个数，顺序)
		//和返回值无关,发生在编译器
		double a = add(10.0, 20);
		System.out.println(a);//30.0

	}

	public static int add(int a, int b) {
		return a + b;
	}

	public static double add(int a, double b) {
		return a + b;
	}

	public static double add(double a, int b) {
		return a + b;
	}

	public static double add(double a, double b) {
		return a + b;
	}

2. Override 重写

在继承关系中，子类如果定义了一个与父类方法签名完全相同的方法，被称为重写（Override）

语法规则:

在子类和父类中有方法名完全一致，返回值类型相同的方法

●发生在子类和父类中，如果父类所提供的方法不能满足子类的需求，则子类可以重写
●方法名相同，参数项相同，返回值也相同，子类的修饰符>=父类的修饰符，方法体不同

返回值:子类重写的方法的返回值范围可以小于父类的方法的返回值范围

父类:
class Person {
    public void run() {
        System.out.println("Person.run");
    }
}
子类: 在子类Student中，重写这个run()方法
class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}
手动重写Object类的方法:

在Java中，所有的class类最终都继承自Object，而Object定义了几个重要的方法
@Override
	public String toString() {
		return "姓名" + name + "身份证号:" + cardId;
	}

	// equals 只能用在引用数据类型上
	// object中的equals方法比较的是两个对象的地址是否相同,String类比较的是内容是否相同(因为其重写了equals方法)
	// 如果自己想要看内容是否相同 重写equals方法
	@Override
	public boolean equals(Object obj) {
		// 1.先比较地址是否相同
		if (this == obj) {
			return true;
		}
		// 2.先判断是否是Person类型
		if (obj instanceof Person) {
			// 向下转型
			Person p1 = (Person) obj;
			return this.name.equals(p1.name) && this.cardId.equals(p1.cardId);
		}
		return false;
	}

	// 地址改成了属性的地址和
	// 如果两个对象的属性完全相同 则hashCode值也完全相同
	@Override
	public int hashCode() {
		return name.hashCode()+cardId.hashCode();
	}
重载重写的区别:

N 区别重载重写
1 概念方法名称相同，参数的类型及个数不同方法名称、返回值类型、参数的类型及个数完全相同
2 范围一个类继承关系
3 限制没有权限要求被重写的方法不能拥有比父类更严格的访问控制权限

N	区别	重载	重写
1	概念	方法名称相同，参数的类型及个数不同	方法名称、返回值类型、参数的类型及个数完全相同
2	范围	一个类	继承关系
3	限制	没有权限要求	被重写的方法不能拥有比父类更严格的访问控制权限