基础知识四

结束多层for循环

      关键字break和continue都是结束循环的作用，但是它只能结束它外面的第一层循环，如果代码里面是一层一层又一层的循环，你想直接结束最外层循环又该怎么做呢？

      此时，就需要outer了。

outer:for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			if(j==0) {
				System.out.print(j);
			}else {
				break outer;   //break;
			}
		}
	}

outer：就相当于表示它现在代表的某个循环。

如果想跳出它所代表的循环，那么就break outer;

如果想结束它所代表的此次循环，那么就continue outer;

注意：这里的outer并不是关键字，而仅仅是一个标签。假如我们把outer替换为其他的词语，也是可以的

---

Boolean初始值是什么？

      包装类(Boolean)默认是Null,基础类型(boolean)默认是false;

---

下面程序输出什么?

 

public class CountTest {

	/**
	 * 计算总数
	 */
	public static void countDemo() {
		int count = 0;
		for (int i = 0; i < 100; i++) {
			count = count++;
		}
		System.out.println(count);
	}

	public static void main(String[] args) {
		countDemo();
	}

}

结果:

 

---

maven项目中常用的生命周期clean、install、package、deploy各自的作用

clean: 清除target目录;

install: 将工程打包到本地仓库，这时本地项目可以依赖，别人是依赖不了的;

package:将项目中的各种文件，比如源代码、编译生成的字节码、配置文件、文档，按照规范的格式生成归档，最常见的当然就是JAR包和WAR包;

deploy: 将打包的jar文件上传到私服(如果有私服)，此时连接私服的人才可以下载依赖。

---

try、catch、finally执行顺序问题

在 Java 的异常处理中，try、catch 和 finally 是按顺序执行的。如果 try 中没有异常，则顺序为 try→finally，如果 try 中有异常，则顺序为 try→catch→finally。

• 无论程序是否有return代码,或者产生异常等,finally中的代码必定会被执行.
• 当finally包含return,返回值只能是finally中return的返回值
• 如果finally没有return,其修改的值,不会影响return的返回值.(ps: 因为return的值会暂存在栈里面，等待finally执行后再返回)
• 执行 try 代码块或 catch 代码块中的 return 语句之前，都会先执行 finally 语句。
• 不建议再finally中包含return代码

	public static void main(String[] args) {
		int returnVal = tryTest();
		System.out.println("执行结果:----------------------"+returnVal);
	}
	
	public static int tryTest (){
	     try {
	         return 1;
	     } catch (Exception e){
	         return 2;
	     }finally{
	         return 3;
	     }
	}

 

---

关于null对象、static变量和方法

有关下述Java代码描述正确的选项是____。

public class TestClass {
    private static void testMethod(){
         System.out.println( "testMethod" );
    }
    public static void main(String[] args) {
         ((TestClass) null ).testMethod();
    }
}

 A、编译不通过
 B、编译通过，运行异常，报NullPointerException
C、编译通过，运行异常，报IllegalArgumentException
D、编译通过，运行异常，报NoSuchMethodException
E、编译通过，运行异常，报Exception
F、运行正常，输出testMethod

正确答案：F

    静态方法是属于类的，静态方法在对象实例创建前就已经存在了，它的使用不依赖于对象是否被创建。当我们通过类的实例来调用时，最后实际上还是将对象实例转换成了类去掉用该静态方法，所以这里的null只是迷惑大家的跟它没有什么关系。

    这里 ((TestClass) null ).testMethod(); 

   也可以写成TestClass t = null; t.testMethod();同样可以正确输出。

   null可以被强制转换成任意类型对象，虽然这个时候t被赋为了空，但这个“空对象”也是属于TestClass的，那么这个“空对象”也就可以去堆上的静态方法区调用testMethod()方法了。

   如果这里testMethod把static去掉，该testMethod方法就变成了实例对象的方法了。这时，可以编译通过，但是会报空指针。

   同理，对于static变量也是一样的。比如 TestClass 中有如下变量：private static String str = "abc"; 我们通过 TestClass t = null; System.out.println(t.str);同样可以正确输出。

---

哪些关键字可以修饰类

一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以有多个类，但只能有一个 public 的类，并且 public 的类名必须与文件名相一致,

外部类不能被private,protected修饰,但是内部类可以,不加修饰符默认就是default,因此一个java源文件中（不是内部类）只能有一个被 public和多个默认符default(不写任何修饰符就是默认)修饰的类 .

哪些关键字可以修饰类?

public ,default (理论上还有private,protected,但是实际情况这两个几乎不会出现在类的修饰中,一般都是修饰方法),还有abstract和final可以和前面的结合使用

---

 

Java中super()的使用

https://blog.csdn.net/yongbutingxide/article/details/82669054

1. super()的使用实例 一一一子类重写父类的方法

public class A {
	
	private String nameA="A";
	
	public void getName() {
		System.out.println("父类"+nameA);
	}
	public static void main(String[] args) {
	}
	
}
 
 
public class B extends A{
	private String nameB="B";
	
	@Override
	public void getName() {
		System.out.println("子类"+nameB);
		super.getName();
	}
	
	public static void main(String[] args) {
		B b=new B();
		b.getName();
	
	}
}

运行结果： 

结果分析：

在子类B中，我们重写了父类的getName方法，如果在重写的getName方法中我们去调用了父类的相同方法，必须要通过super关键字显示的指明出来。

如果不明确出来，按照子类优先的原则，相当于还是再调用重写的getName()方法，此时就形成了死循环，执行后会报java.lang.StackOverflowError异常。如下图所示：

2. super()的使用实例 一一一子类重写父类的变量

public class A {
	
	 String nameA="A";
 
}
 
public class B extends A{
	 String nameA="B";
	
	
	public void getName() {
		System.out.println("子类"+nameA);
		System.out.println("父类"+super.nameA);
	}
	
	public static void main(String[] args) {
		B b=new B();
		b.getName();
	
	}
}

 运行结果：

此时子类B中有一个和父类一样的字段（也可以说成父类字段被隐藏了），为了获得父类的这个字段我们就必须加上super，如果没有加，直接写成name = name;不会报错，只是会警告，表示此条语句没有任何意义，因为此时都是访问的子类B里面的那么字段。

我们通过super是不能访问父类private修饰的变量和方法的，因为这个只属于父类的内部成员，一个对象是不能访问它的private成员的。

3. super()的使用实例 一一一在子类的构造方法中

编译器会自动在子类构造函数的第一句加上 super(); 来调用父类的无参构造器；此时可以省略不写。如果想写上的话必须在子类构造函数的第一句，可以通过super来调用父类其他重载的构造方法，只要相应的把参数传过去就好。

因此，super的作用主要在下面三种情况下：

1、调用父类被子类重写的方法；

2、调用父类被子类重定义的字段（被隐藏的成员变量）；

3、调用父类的构造方法；

其他情况，由于子类自动继承了父类相应属性方法，关键字super可以不显示写出来。

4. 关于构造方法中super()

第一种情况：编译不通过

分析：

如果一个类中没有写任何的构造方法，JVM会生成一个默认的无参构造方法。在继承关系中，由于在子类的构造方法中，第一条语句默认为调用父类的无参构造方法（即默认为super()，一般这句话省略了）。所以当在父类中定义了有参构造函数，而没有定义无参构造函数时，IDE会强制要求我们定义一个相同参数类型的构造器。

在本例中JVM默认给B加了一个无参构造方法，而在这个方法中默认调用了super()，但是父类中并不存在该构造方法

 

第二种情况：编译不通过

同样编译错误，相同的道理，虽然我们在子类中自己定义了一个构造方法，但是在这个构造方法中还是默认调用了super()，但是父类中并不存在该构造方法 

 

第三种情况：成功编译通过

public class A {
	public A(String s) {
		
	}
 
}
 
public class B extends A{
	public B(String s) {
		super(s);
	}
}

分析：

所以，只要记住，在子类的构造方法中，只要里面没有显示的通过super去调用父类相应的构造方法，默认都是调用super()，即无参构造方法，因此要确保父类有相应的构造方法。

 

 

---