• JAVA基础（十二）

    关键字：static

    当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上 的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象， 其方法才可以供外部调用。

    我们有时候希望无论是否产生了对象或无论产生了多少 对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个 国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中 都单独分配一个用于代表国家名称的变量。

    使用static修饰属性：静态变量

    使用范围：

            在Java类中，可用static修饰属性、方法、代码块、内部类

    被修饰后的成员具备以下特点：

            随着类的加载而加载

            优先于对象存在

            修饰的成员，被所有对象所共享

            访问权限允许时，可不创建对象，直接被类调用

            类中的常量也常常声明为static 

            由于类只会加载一次，则静态变量在内存也只会存在一份，存放在方法区的静态域中。

            属性的分类：按是否使用static修饰，又分为：静态属性和非静态属性（实例变量）。

                    实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中一个对象的非静态属性时，不会导致其他对象中同样的属性值的修改。                                                                           

                    静态变量：我们创建了类的多个对象，多个对象共享一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过的                                       

     如果想让一个类的所有实例共享数据，就用类变量！

    静态结构使用例：

    System.out 、Math.PI

     使用static修饰方法：静态方法

            随着类的加载二加载，可以通过类.静态方法的方式进行调用

            静态方法中只能调用静态的方法或属性

            非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

            静态方法中不能使用this和super关键字

    类属性、类方法的设计思想

    类属性作为该类各个对象之间共享的变量。在设计类时,分析哪 些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。

    如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。

    操作静态属性的方法通常设置为静态

    工具类的方法习惯上声明为static

    测试代码

    1. package com.xxx.java;
    2.  
    3. public class StaticTest {
    4. 	public static void main(String[] args) {
    5. 		
    6. 		Chinese c1 = new Chinese();
    7. 		c1.name = "姚明";
    8. 		c1.age = 40;
    9. 		
    10. 		Chinese c2 = new Chinese();
    11. 		c2.name = "马龙";
    12. 		c2.age = 30; 
    13. 		
    14. 		c1.nation = "CHN";
    15. 		System.out.println(c2.nation);
    16. 		
    17. 		Chinese.show();
    18. 		//Chinese.eat();
    19. 	}
    20. }
    21.  
    22. class Chinese{
    23. 	
    24. 	String name;
    25. 	int age;
    26. 	static String nation;
    27. 	
    28. 	public void eat() {
    29. 		System.out.println("吃中餐");
    30. 	}
    31. 	
    32. 	public static void show() {
    33. 		System.out.println("我是一个中国人");
    34. 		//eat();
    35. 		//name = "Tom";
    36. 		//可以调用静态的结构
    37. 		nation = "中国";
    38. 		walk();
    39. 	}
    40. 	
    41. 	public static void walk() {
    42. 		System.out.println("走路");
    43. 	}
    44. }

    ArrayUtil工具类优化

    1. package com.xxx.java;
    2.  
    3. //自定义数组工具类
    4.  
    5. public class ArrayUtil {
    6. 	// 求数组的最大值
    7. 	public static int getMax(int[] arr) {
    8. 		int max = arr[0];
    9. 		for (int i = 0; i < arr.length; i++) {
    10. 			if (max < arr[i]) {
    11. 				max = arr[i];
    12. 			}
    13. 		}
    14. 		return max;
    15. 	}
    16.  
    17. 	// 求数组的最小值
    18. 	public static int getMin(int[] arr) {
    19. 		int min = arr[0];
    20. 		for (int i = 0; i < arr.length; i++) {
    21. 			if (min > arr[i]) {
    22. 				min = arr[i];
    23. 			}
    24. 		}
    25. 		return min;
    26. 	}
    27.  
    28. 	// 求数组的总和
    29. 	public static int getSum(int[] arr) {
    30. 		int sum = 0;
    31. 		for (int i = 0; i < arr.length; i++) {
    32. 			sum += arr[i];
    33. 		}
    34. 		return sum;
    35. 	}
    36.  
    37. 	// 求数组的平均值
    38. 	public static int getAvg(int[] arr) {
    39. 		return getSum(arr) / arr.length;
    40. 	}
    41.  
    42. 	// 反转数组
    43. 	public static void reverse(int[] arr) {
    44. 		for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
    45. 			int temp = arr[i];
    46. 			arr[i] = arr[j];
    47. 			arr[j] = temp;
    48. 		}
    49. 	}
    50.  
    51. 	// 复制数组
    52. 	public static int[] copy(int[] arr) {
    53. 		int[] arr1 = new int[arr.length];
    54. 		for (int i = 0; i < arr.length; i++) {
    55. 			arr1[i] = arr[i];
    56. 		}
    57. 		return arr1;
    58. 	}
    59.  
    60. 	// 数组排序
    61. 	public static void sort(int[] arr) {
    62. 		for (int i = 0; i < arr.length; i++) {
    63. 			for (int j = 0; j < arr.length - 1 - i; j++) {
    64. 				if (arr[j] > arr[j + 1]) {
    65. 					swap(arr,j,j+1);
    66. 				}
    67. 			}
    68. 		}
    69. 	}
    70.  
    71. 	// 遍历数组
    72. 	public static void print(int[] arr) {
    73. 		for (int i = 0; i < arr.length; i++) {
    74. 			System.out.print(arr[i] + " ");
    75. 		}
    76. 	}
    77.  
    78. 	// 查找指定元素
    79. 	public static int getIndex(int[] arr, int dest) {
    80.  
    81. 		for (int i = 0; i < arr.length; i++) {
    82. 			if (dest == arr[i]) {
    83. 				return i;
    84. 			}
    85. 		}
    86. 		return -1;
    87. 	}
    88. 	//交换数组中指定两个位置元素的值
    89. 	private static void swap(int[]arr,int i,int j) {
    90. 		int temp = arr[i];
    91. 		arr[i] = arr[j];
    92. 		arr[j] = temp;
    93. 	}
    94. }

    测试

    1. package com.xxx.java;
    2.  
    3. public class ArrayUtilTest {
    4. 	public static void main(String[] args) {
    5. 		//ArrayUtil util = new ArrayUtil();
    6. 		int[] arr = {32,34,32,5,3,54,654,-98,0,-53,5};
    7. 		
    8. 		int max = ArrayUtil.getMax(arr);
    9. 		System.out.println("最大值为：" + max);
    10. 		
    11. //		System.out.println("排序前");
    12. //		ArrayUtil.print(arr);
    13. //		
    14. //		ArrayUtil.sort(arr);
    15. //		System.out.println();
    16. //		System.out.println("排序后");
    17. //		ArrayUtil.print(arr);
    18. 		
    19. 		System.out.print("查找：");
    20. 		int index = ArrayUtil.getIndex(arr, -5);
    21. 		if (index >= 0) {
    22. 			System.out.println(index);
    23. 		} else {
    24. 			System.out.println("没找到");
    25. 		}
    26. 	}
    27. }

    相关应用

    1. package com.xxx.java;
    2.  
    3. public class CircleTest {
    4. 	public static void main(String[] args) {
    5. 		Circle c1 = new Circle();
    6. 		Circle c2 = new Circle();
    7. 		Circle c3 = new Circle(3.4);
    8. 		
    9. 		System.out.println("c1的id为：" + c1.getId());
    10. 		System.out.println("c2的id为：" + c2.getId());
    11. 		System.out.println("c3的id为：" + c3.getId());
    12. 		
    13. 		System.out.println("创建的圆的个数为：" + Circle.getTotal());
    14. 	}
    15. }
    16.  
    17. class Circle {
    18. 	private double radius;
    19. 	private int id;
    20.  
    21. 	private static int total;
    22. 	private static int init = 1001;
    23. 	
    24. 	
    25. 	
    26. 	public Circle() {
    27. 		super();
    28. 		id = init++;
    29. 		total++;
    30. 	}
    31.  
    32.  
    33.  
    34. 	public Circle(double radius) {
    35. 		this();
    36. 		this.radius = radius;
    37. 		//id = init++;
    38. 		//total++;
    39. 	}
    40.  
    41.  
    42.  
    43. 	public static int getTotal() {
    44. 		return total;
    45. 	}
    46.  
    47.  
    48.  
    49. 	public double getRadius() {
    50. 		return radius;
    51. 	}
    52.  
    53.  
    54.  
    55. 	public void setRadius(double radius) {
    56. 		this.radius = radius;
    57. 	}
    58.  
    59.  
    60.  
    61. 	public int getId() {
    62. 		return id;
    63. 	}
    64.  
    65.  
    66.  
    67. 	public double findArea() {
    68. 		return 3.14 * radius * radius;
    69. 	}
    70. }

    相关练习

    编写一个类实现银行账户的概念，包含的属性有“帐号”、“密 码”、“存款余额”、“利率”、“最小余额”，定义封装这些 属性的方法。账号要自动生成。

    编写主类，使用银行账户类，输入、输出3个储户的上述信息。 考虑：哪些属性可以设计成static属性。

    1. package com.xxx.exer;
    2.  
    3. public class Account {
    4. 	private int id;
    5. 	private String pwd = "000000";
    6. 	private double balance;
    7.  
    8. 	private static double interestRate;
    9. 	private static double minMoney;
    10. 	private static int init;
    11. 	
    12. 	
    13.  
    14. 	public Account() {
    15. 		super();
    16. 		id = init++;
    17. 	}
    18. 	
    19.  
    20. 	public Account(String pwd, double balance) {
    21. 		this();
    22. 		this.pwd = pwd;
    23. 		this.balance = balance;
    24. 	}
    25.  
    26.  
    27. 	public String getPwd() {
    28. 		return pwd;
    29. 	}
    30.  
    31. 	public void setPwd(String pwd) {
    32. 		this.pwd = pwd;
    33. 	}
    34.  
    35. 	public static double getInterestRate() {
    36. 		return interestRate;
    37. 	}
    38.  
    39. 	public static void setInterestRate(double interestRate) {
    40. 		Account.interestRate = interestRate;
    41. 	}
    42.  
    43. 	public static double getMinMoney() {
    44. 		return minMoney;
    45. 	}
    46.  
    47. 	public static void setMinMoney(double minMoney) {
    48. 		Account.minMoney = minMoney;
    49. 	}
    50.  
    51. 	public int getId() {
    52. 		return id;
    53. 	}
    54.  
    55. 	public double getBalance() {
    56. 		return balance;
    57. 	}
    58.  
    59.  
    60. 	@Override
    61. 	public String toString() {
    62. 		return "Account [id=" + id + ", pwd=" + pwd + ", balance=" + balance + "]";
    63. 	}
    64.  
    65. }

    测试

    1. package com.xxx.exer;
    2.  
    3. public class AccountTest {
    4. 	public static void main(String[] args) {
    5. 		Account.setInterestRate(0.012);
    6. 		Account.setMinMoney(100);
    7. 		
    8. 		Account acc1 = new Account();
    9. 		Account acc2 = new Account("114514",2000);
    10. 		
    11. 		System.out.println(acc1);
    12. 		System.out.println(acc2);
    13. 		System.out.println(Account.getInterestRate());
    14. 		System.out.println(Account.getMinMoney());
    15. 	}
    16. }

    单例 (Singleton)设计模式

    设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、 以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。”套路”

    所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对 某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构 造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生 类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无 法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象 的变量也必须定义成静态的。

    饿汉式：

    1. package com.xxx.java1;
    2.  
    3. public class SingletonTest1 {
    4. 	public static void main(String[] args) {
    5. 		Bank bank1 = Bank.getInstance();
    6. 		Bank bank2 = Bank.getInstance();
    7. 		
    8. 		System.out.println(bank1 = bank2);
    9. 	}
    10. 	
    11. }
    12. //饿汉式
    13. class Bank{
    14. 	//私有化构造器
    15. 	private Bank(){
    16. 		
    17. 	}
    18. 	//内部创建类的对象
    19. 	//要求声明为静态，否则静态方法中无法调用
    20. 	private static Bank instance = new Bank();
    21. 	
    22. 	//提供public的方法，返回类的对象
    23. 	public static Bank getInstance() {
    24. 		return instance;
    25. 	}
    26. }

    懒汉式：

    1. package com.xxx.java1;
    2.  
    3. public class SingletonTest2 {
    4. 	public static void main(String[] args) {
    5. 		Order order1 = Order.getInstance();
    6. 		Order order2 = Order.getInstance();
    7. 		
    8. 		System.out.println(order1 == order2);
    9. 	}
    10. }
    11. //懒汉式
    12. class Order {
    13. 	//私有化类的构造器
    14. 	private Order() {
    15.  
    16. 	}
    17. 	//声明当前类对象，不进行初始化
    18. 	private static Order instance = null;
    19. 	
    20. 	//声明public static的返回当前类对象的方法
    21. 	public static Order getInstance() {
    22. 		//不判断会每次执行时都新生成一个对象实例
    23. 		if(instance == null) {
    24. 			instance = new Order();
    25. 		}
    26. 		return instance;
    27. 	}
    28. }

    区分饿汉式和懒汉式：

            懒汉式：

                    优点：延迟对象的创建

                    缺点：线程不安全——到多线程时修改

            饿汉式：

                    优点：饿汉式是线程安全的

                    缺点：对象加载时间过长

    单例模式的优点：

            由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的 产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决

    应用场景

     网站的计数器，一般也是单例模式实现，否则难以同步。

     应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

     数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

     项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。

     Application 也是单例的典型应用

     Windows的Task Manager (任务管理器)就是很典型的单例模式

     Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

    理解main方法的语法

    说明

            作为程序的入口

            是一个普通的静态方法

    public：由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public

    static：又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的

    void：main方法执行完后程序就结束了，不需要返回值

    形参：该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行               的类的参数。

    形参的使用方式（Eclipse）

    1.先run as一遍代码

    2.选择Run Configurations 

     3.左侧选择当前编译好的字节码文件，右侧选择Arguments

    在Program arguments框内输入字符串，空格隔开，可以不加双引号。Run运行程序 

    执行结果如下

     相关代码

    1. package com.xxx.java1;
    2.  
    3. public class MainDemo {
    4. 	public static void main(String[] args) {
    5. 		for (int i = 0; i < args.length; i++) {
    6. 			System.out.println("***********" + args[i]);
    7. 		}
    8. 	}
    9. }

    若是其他基本数据类型，可以使用包装类的parseXxx方法 

    1. package com.xxx.java1;
    2.  
    3. public class MainTest {
    4. 	public static void main(String[] args) {
    5. 		Main.main(new String[100]);
    6. 	}
    7. }
    8.  
    9. class Main{
    10. 	public static void main(String[] args) {
    11. 		args = new String[100];
    12. 		for (int i = 0; i < args.length; i++) {
    13. 			args[i] = "args_" + i;
    14. 			System.out.println(args[i]);
    15. 		}
    16. 	}
    17. }

     形参的使用方式（控制台）

    1、先删掉包名，在编译javac xxx

    2、java xxx 形参

    代码块（或初始化块）

    代码块(或初始化块)的作用：对Java类或对象进行初始化。

    代码块(或初始化块)的分类：

            一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块 (static block)，没有使用static修饰的，为非静态代码块。         

    static代码块通常用于初始化static的属性

    静态代码块：

            可以有输出语句。

            初始化类的信息。

            不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。

            若有多个静态的代码块，那么按照从上到下的顺序依次执行。

            静态代码块的执行要先于非静态代码块。

            静态代码块随着类的加载而加载，且只执行一次。

    非静态代码块:

            可以有输出语句。

            可以在创建对象时，对对象的属性进行初始化。

            除了调用非静态的结构外，还可以调用静态的变量或方法。

            若有多个非静态的代码块，那么按照从上到下的顺序依次执行。

            每次创建对象的时候，都会执行一次。且先于构造器执行。

    代码

    1. package com.xxx.java2;
    2.  
    3. public class BlockTest {
    4. 	public static void main(String[] args) {
    5. 		String desc = Person.desc;
    6. 		System.out.println(desc);
    7. 		Person p1 = new Person();
    8. 		Person p2 = new Person();
    9. 		System.out.println(p1.age);
    10. 		Person.info();
    11. 	}
    12. }
    13.  
    14. class Person {
    15. 	//属性
    16. 	String name;
    17. 	int age;
    18. 	static String desc = "我是一个人";
    19.  
    20. 	//构造器
    21. 	public Person() {
    22.  
    23. 	}
    24.  
    25. 	public Person(String name,int age) {
    26. 		this.name = name;
    27. 		this.age = age;
    28. 	}
    29. 	
    30. 	//代码块
    31. 	static {
    32. 		System.out.println("hello,static block-1");
    33. 		desc = "我是一个爱学习的人";
    34. 		info();
    35. 	}
    36. 	static {
    37. 		System.out.println("hello,static block-2");
    38. 	}
    39. 	
    40. 	{
    41. 		System.out.println("hello,block-1");
    42. 		age = 1;
    43. 	}
    44. 	{
    45. 		System.out.println("hello,block-2");
    46. 	}
    47. 	//方法
    48. 	public void eat() {
    49. 		System.out.println("吃饭");
    50. 	}
    51.  
    52. 	@Override
    53. 	public String toString() {
    54. 		return "Person [name=" + name + ", age=" + age + "]";
    55. 	}
    56. 	
    57. 	public static void info() {
    58. 		System.out.println("我是一个快乐的人");
    59. 	}
    60. }

    使用示例

            例1

    1. package com.xxx.java2;
    2. class Root{
    3. 	static{
    4. 		System.out.println("Root的静态初始化块");
    5. 	}
    6. 	{
    7. 		System.out.println("Root的普通初始化块");
    8. 	}
    9. 	public Root(){
    10. 		System.out.println("Root的无参数的构造器");
    11. 	}
    12. }
    13. class Mid extends Root{
    14. 	static{
    15. 		System.out.println("Mid的静态初始化块");
    16. 	}
    17. 	{
    18. 		System.out.println("Mid的普通初始化块");
    19. 	}
    20. 	public Mid(){
    21. 		System.out.println("Mid的无参数的构造器");
    22. 	}
    23. 	public Mid(String msg){
    24. 		//通过this调用同一类中重载的构造器
    25. 		this();
    26. 		System.out.println("Mid的带参数构造器，其参数值："
    27. 			+ msg);
    28. 	}
    29. }
    30. class Leaf extends Mid{
    31. 	static{
    32. 		System.out.println("Leaf的静态初始化块");
    33. 	}
    34. 	{
    35. 		System.out.println("Leaf的普通初始化块");
    36. 	}	
    37. 	public Leaf(){
    38. 		//通过super调用父类中有一个字符串参数的构造器
    39. 		super("尚硅谷");
    40. 		System.out.println("Leaf的构造器");
    41. 	}
    42. }
    43. public class LeafTest{
    44. 	public static void main(String[] args){
    45. 		new Leaf(); 
    46. 		//new Leaf();
    47. 	}
    48. }
    49.

    解析：

    先加载父类和间接父类，然后加载每个类静态代码块即：

            加载Object的静态代码块（无）

            加载Root的静态代码块

            加载Mid的静态代码块

            加载Leaf的静态代码块

    之后对象创建完毕，先加载父类和间接父类的构造器，而此时非静态代码块先于父类构造器执行：

            加载Object的代码块（无），加载Object的构造器（无内容）

            加载Root的代码块，加载Root的构造器

            加载Mid的代码块，加载Mid的无参构造器，加载Mid的带参构造器

            加载Leaf的代码块，加载Leaf的构造器        

    若再次new Leaf（），静态代码块内容不在执行

            例2

    1. package com.xxx.java2;
    2.  
    3. class Father {
    4. 	static {
    5. 		System.out.println("11111111111");
    6. 	}
    7. 	{
    8. 		System.out.println("22222222222");
    9. 	}
    10.  
    11. 	public Father() {
    12. 		System.out.println("33333333333");
    13. 	}
    14.  
    15. }
    16.  
    17. public class Son extends Father {
    18. 	static {
    19. 		System.out.println("44444444444");
    20. 	}
    21. 	{
    22. 		System.out.println("55555555555");
    23. 	}
    24. 	public Son() {
    25. 		System.out.println("66666666666");
    26. 	}
    27.  
    28.  
    29. 	public static void main(String[] args) { // 由父及子 静态先行
    30. 		System.out.println("77777777777");
    31. 		System.out.println("************************");
    32. 		new Son();
    33. 		//System.out.println("************************");
    34.  
    35. 		//new Son();
    36. 		//System.out.println("************************");
    37. 		//new Father();
    38. 	}
    39.  
    40. }

    解析： 

            main方法是由当前main所在的类通过类.main调用的,所有先初始化当前类以及他的父类和间接父类             

            当前main方法在Son中，由Son.main()调用，要初始化Son就要先初始化Son的父类和间接父类         

            初始化Object

            初始化Father（静态代码块）

            初始化Son（静态代码块）

    后续执行同例1

    结果为：1 4 7 * 2 3 5 6 * 2 3 5 6 * 2 3

    对属性的赋值顺序

    1.默认初始化

    2.显式初始化 / 3在代码块中赋值

    4构造器中初始化

    5对象.属性或对象.方法的方式赋值

    执行顺序1——2 / 3——4——5

    1. package com.xxx.java2;
    2.  
    3. public class OrderTest {
    4. 	public static void main(String[] args) {
    5. 		Order o = new Order();
    6. 		System.out.println(o.orderId);
    7. 	}
    8. }
    9.  
    10. class Order{
    11. //	int orderId = 3;
    12. //	{
    13. //		orderId = 4;
    14. //	}
    15. 	{
    16. 		orderId = 4;
    17. 	}
    18. 	int orderId = 3;
    19. 	
    20. }

    关键字：native

    native关键字声明调用底层c或c++的方法

    关键字：final

    在Java中声明类、变量和方法时，可使用关键字final来修饰。

            final标记的类不能被继承。

                    内置的final类：String、System、StringBuffer

            final标记的方法不能被子类重写。

                    内置的funal方法：Object的getClass()

    final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。

            final修饰属性，可以赋值的位置有

                    显式初始化、在代码块中赋值、在构造器中赋值

            final修饰局部变量：为常量，无法修改

                          修饰形参：表示此形参是一个常量，只能在方法内使用该形参，不能对其进行修改

            static final：修饰属性 全局常量

    1. package com.xxx.java2;
    2.  
    3. public class FinalTest {
    4.  
    5. 	// final int UP; 无法默认初始化赋值
    6. 	final int WIDTH = 10; // 可以显式初始化赋值
    7. 	// 可以在代码块内赋值
    8. 	final int LEFT;
    9.  
    10. 	{
    11. 		LEFT = 1;
    12. 	}
    13. 	// 可以在构造器中赋值,但每个构造器中都必须赋值
    14. 	final int RIGHT;
    15.  
    16. 	public FinalTest() {
    17. 		RIGHT = 2;
    18. 	}
    19.  
    20. 	public FinalTest(int n) {
    21. 		RIGHT = n;
    22. 	} 
    23. 	//不可以在方法中赋值
    24. //	final int DOWN;
    25. //
    26. //	public int setDOWN(int down) {
    27. //		DOWN = down;
    28. //	}
    29.  
    30. 	// public void doWidth() {
    31. //		WIDTH = 20;
    32. //	}
    33. 	
    34. 	public void show() {
    35. 		final int NUM = 10;	//常量
    36. 		//NUM += 1;
    37. 	}
    38. 	public void show(final int num) {
    39. 		//num = 5;
    40. 		System.out.println(num);
    41. 		
    42. 	}
    43. 	public static void main(String[] args) {
    44. 		FinalTest test = new FinalTest();
    45. 		//test.setDOWN(5);
    46. 		test.show(10);
    47. 	}
    48. }
    49.  
    50. final class FinalA {
    51.  
    52. }
    53.  
    54. //class B extends FinalA{
    55. //	
    56. //}
    57.  
    58. //class C extends String{
    59. //	
    60. //}
    61.  
    62. class AA {
    63. 	public final void name() {
    64.  
    65. 	}
    66. }
    67.  
    68. class BB extends AA {
    69. //	public void name() {
    70. //		
    71. //	}
    72. }

    练习：

    1

    1. public class Something {
    2.     public int addOne(final int x) {
    3.         return ++x;        //不行
    4.         // return x + 1;    //可以，x本身没有变
    5.     }
    6. }

    2

    1. public class Something {
    2.     public static void main(String[] args) {
    3.         Other o = new Other();
    4.         new Something().addOne(o);
    5.     }
    6.  
    7.     public void addOne(final Other o) {
    8.     // o = new Other();    //不行，地址变了
    9.     o.i++;        //可以，地址没有变
    10.     }
    11. }
    12.  
    13. class Other {
    14.     public int i;
    15. }

  • 相关阅读:
    【云原生之K8S】K8S管理工具kubectl 详解
    springboot整合webSocket（看完即入门）
    http post协议发送本地压缩数据到服务器
    mysql跨库关联查询（dblink）
    数据可视化分析之新技能——魔数图
    go设计模式之工厂方法模式
    mysql_命令行启动_win10
    5.云原生-KubeSphere3.3.0安装Harbor仓库
    九、MySQL之视图的介绍
    分享如何通过股票交易行情数据接口获取日线行情
  • 原文地址：https://blog.csdn.net/m0_56413004/article/details/126146611