java编程基础总结——12.字符串格式化、final关键字、内部类

一、字符串格式化的方法：

format()        // 静态方法

String name = "小豪";
int age = 13;
String address = "陕西";
double money = 231256566.12365152001;
System.out.println("我的名字叫做："+ name +"，我今年"+ age +"岁了，我是来自于"+ address);//一般输出

格式化方法，完全支持c中的printf格式化

%d 整数  %f浮点数（double float都可以） %c char类型     %s字符串（建议使用，最终都可以转换成字符串）位数取舍的时候不用

静态方法，通过类型类名调用

System.out.println(String.format("我的名字叫做%s, 我今年%d，我来自于%s，他的身价是%.3f", name, age, address, money));

// %.3f保留三位小数（四舍五入）

System.out.printf("我的名字叫做%s, 我今年%s，我来自于%s，他的身价是%.3f", name, age, address, money);
    

二、final关键字：

 final：最终、最后
1、一旦被它修饰变量，成为了常量
        static final

// 定义常量、恒量

static final double PI = 3.14;

    不能把常量定义在某个方法（局部变量）里

2、  final除了修饰常量外，也可以修饰方法或者类

        如果final修饰了方法，该方法将无法被重写（override）

     （开发中，有时候做了很多工具类等，不希望子类去修改，避免出问题）

package com.openlab.day13;

public class TestInstanceof {
	
	// 定义常量、恒量
	//static final double PI = 3.14;
	
	public static void main(String[] args) {
	
		Dog dog = new Dog();
		dog.say();
		
	}
}

class Animal {
	
	public void say() {
		System.out.println("呜呜呜，我是一只动物");
	}
}

class Dog extends Animal {
    //不报错
	@Override
	public void say() {
		System.out.println("我是一只狗，汪汪汪");
	}

	
}

package com.openlab.day13;

public class TestInstanceof {
	
	// 定义常量、恒量
	//static final double PI = 3.14;
	
	public static void main(String[] args) {
	
		Dog dog = new Dog();
		dog.say();
		
	}
}

class Animal {
	
	// 最终的方法，最后方法，无法重写
	public final void say() {
		System.out.println("呜呜呜，我是一只动物");
	}
}

class Dog extends Animal {
    //报错，不能被重写
	/*@Override
	public void say() {
		System.out.println("我是一只狗，汪汪汪");
	}*/

}

class Cat extends Animal {
	
}

3、final关键字也可以修饰类，一旦某个类被final修饰，该类将无法被继承。

final class Animal {
	
	// 最终的方法，最后方法，无法重写
	public final void say() {
		System.out.println("呜呜呜，我是一只动物");
	}
}

//报错，无法被继承
/*class Dog extends Animal {  

}

class Cat extends Animal {
	
}*/

【总结作业】面试题：为什么字符串使用final关键字

三、内部类：

内部类，指的就是定义在某个类内部的类。

1. 什么是内部类：

     将类写在其他类的内部，可以写在其他的成员位置和其他类的局部位置，这时写在其他类内部的类 就称为内部类。

2. 如何定义内部类：

package com.openlab.day13;

public class TestInnerClass {
	// 外界无法访问num
	private int num = 20;
	
	// 内部类，就是外部类的成员之一
	class Inner {

		// 内部类的方法
		public void say() {
			// 可以直接访问到外部类的私有成员
			System.out.println(num);
		}
    }
}

3. 有哪些访问修饰符可以使用在内部类

        public private 默认 static final 这些修饰符可以使用在内部类

        一般内部类是去访问外部类的成员，很少露在外面（露在外面写成普通类即可），所以内部         类很少是public ，很少跨包

        内部类也很少用private(除非main函数在内部类的外部类中，否则内部类无用)

4. 如何在外界访问对象

        内部类可以直接访问外部类中的成员，但外部类不能直接访问内部类，若要访问，必须创建内部类对象才能访问

普通内部类：

package com.openlab.day13;

public class TestInnerClass {
	// 外界无法访问num
	private int num = 20;
	
	// 内部类，就是外部类的成员之一
	// public private 默认 static final 这些修饰符可以使用在内部类
	class Inner {
		
		// 内部类的方法
		public void say() {
			// 可以直接访问到外部类的私有成员
//			System.out.println(num);
		}
		
	}
	
	public void show() {
		System.out.println("普通方法");
	}
}

package com.openlab.day13;

import com.openlab.day13.TestInnerClass.Inner;

public class Test {

	public static void main(String[] args) {
//		TestInnerClass tic = new TestInnerClass();
//		tic.show();普通方法
		
		// 在外界创建内部类的对象方式（内部类不是静态和私有的内部类）
		Inner inner = new TestInnerClass().new Inner();
		// 如何在外界创建内部类的对象
		inner.say();
		
	}
}

静态内部类：

访问静态内部类的静态成员

由于内部类是静态的，可以直接使用外部类名调用内部类，而内部类的成员也是静态的，这时同样

可以通过类名调用内部类的静态成员。

public class Test { 
    public static void main(String[] args) { 
//既然静态内部类已随外部类加载，而且静态成员随着类的加载而加载，就不需要对象，直接用类名调用即可                                                         
        Outer.Inner.show2(); 
    } 
}

class Outer{ 
    //外部类的成员变量     
    static int num = 5; 
    //写在Outer成员位置上的静态内部类 
    static class Inner{ 
        //内部类的静态方法 
        static void show2(){ 
            System.out.println("static Inner method num = "+num); 
        } 
    } 
}

使用 static 修饰内部类，该内部类属于其外部类，而不属于外部类的对象；

static只是对外界访问有区别，不影响内部类。内部类和类一样，既可以有static的属性和方法，也可以有普通成员和方法

public class TestInnerClass {
   // private int num = 20;

    // static修饰内部类
    static class Inner {

        //内部类可以有普通方法
        public void say() {
            // 不能直接访问到外部类的私有成员
            //System.out.println(num);
        }

        public static void test() {
            //内部类可以有静态方法
        }
    }
}

// 如果是静态内部类，直接使用类名称方法
        Inner inner = new TestInnerClass.Inner();
        inner.say();

一旦私有内部类，外界无法拿到内部类的任何东西（意义也不大，除非main函数在TestInnerClass 类中，否则内部类无用）

public class TestInnerClass { 

        private class Inner {

        }
 }

案例：

public class Test { 
    public static void main(String[] args) {
         Outer.Inner in = new Outer().new Inner(); 
        in.show(); 
    } 
}

class Outer { 
    int num = 5;// 外部类的成员变量 
    class Inner {
        int num = 6;// 内部类的成员变量  
        void show() { 
        int num = 7; // 内部类局部变量 
        System.out.println("内部类局部num=" + num); 
        System.out.println("内部类成员num=" + this.num); 
        System.out.println("外部类成员num=" + Outer.this.num); 
        } 
    } 
}

为什么内部类可以直接访问外部类的成员，那时因为内部类持有外部类的引用（外部类.this）。对

于静态内部类不持有 外部类.this 而是直接使用 外部类名。