重庆—java互联网架构软件工程师学习记录—Day09（面向对象3）

Java互联网架构软件工程师——第一阶段

Day09–面向对象3

---

前言

今天主要学习static和final 两个关键字 和 多态的使用，还有异常的相关知识

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、static关键字

1.1 概述

1、 是java中的一个关键字
2、 用于修饰成员 （成员变量和成员方法）

1.2 特点

—可以修饰成员变量，成员方法
—随着类的加载而加载，优先于对象加载
—只加载一次，就会一直存在，不再开辟新空间
—全局唯一，全局共享
—可以直接被类名调用
—静态只能调用静态，非静态可以随意调用
—static不能和this或者super共用

1.3 入门案例

代码如下（示例）：

//测试 静态关键字
		public class Test1_Staticc {
			public static void main(String[] args) {
				//TODO 2,静态资源比对象 先加载进内存
				Person.code();
				System.out.println(Person.name);
				
				//TODO 3,普通资源只能通过对象访问
				Person p = new Person();
				p.eat();
				System.out.println(p.age);
				
				//TODO 4,静态资源的访问方式:对象或者类名
				System.out.println(p.name);
				p.code();
				Person.code();
				System.out.println(Person.name);
				
				//TODO 5,多个对象间全局共享
				Person p2 = new Person();
				Person p3 = new Person();
				p2.name="jerry";
				System.out.println(p3.name);//jerry
			}
		}
		class Person{
			//TODO 普通资源
			int age = 10;
			public void eat(){
				//普通资源 调用 静态资源 - 可以
				System.out.println(name);
				System.out.println("吃肉");
			}
			//TODO 1, 静态资源 --随着类的加载而加载
			static String name = "jack";
			static void code(){
				//静态资源 调用 普通资源 - 不可以,
				//6,静态资源 调用 静态资源
		//		System.out.println(age);
		//		eat();
				System.out.println("code..");
			}
		}

二、静态代码块

2.1 概述

1、 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的 初始化
2、 构造代码块：在调用构造方法前会自动调用，每次创建对象都会被调用
3、 局部代码块：方法里的代码块，方法被调用时才会执行
4、 静态代码块：static{ }，位置：在类里方法外

2.2 入门案例

代码如下（示例）：

//测试 静态代码块
//总结
//1,触发节点:
//1,当类加载时,执行 静态代码块
//2,当实例化时,先执行 构造代码块 再执行构造方法
//3,当调用方法时,执行 局部代码块
//执行顺序:静态代码块>构造代码块>构造方法>局部代码块
public class Test03 {
	public static void main(String[] args) {
		/*Person2 a = new Person2();
		a.show();*/
		
		new Person2().show();
		new Person2().show();
	}

}
class Person2{
	
	//TOOD 静态代码块---在成员位置---类加载时触发---完成项目的初始化
	static{
		//来得早，走得晚 ；只加载一次
		System.out.println(9);
	}
	
	
	//TOOD 构造代码块---在成员位置---new是触发--用来提取共性
	{
		System.out.println(1);
	}
	//TOOD Constructor ---new 时触发---用来创建对象
	public Person2(){
		System.out.println(222);
	}
	//TOOD 局部代码块---在局部位置---调用方法时触发---控制变量
	public static void show(){
		System.out.println(2);
	}
	  
}

三、final关键字

3.1 概述

当子类继承了父类以后,子类可以用父类的所有功能,还能扩展,还能改.
如果父类的功能,只让继承,不许改–用final

3.2 使用场景

—可以修饰类,是最终的类,不能被继承
—可以修饰方法,不能被重写
—可以修饰变量,值不能被修改,变成了常量

3.3 入门案例

代码如下（示例）：

//测试 final关键字
//--可以修饰类,是最终的类,不能被继承
//--可以修饰方法,不能被重写
//--可以修饰常量,值不能被修改,变成了常量
		public class Test3_Final {
			public static void main(String[] args) {
				//TODO 创建对象 测试
				Zi zi = new Zi();
		//		zi.age = 30;
				System.out.println(zi.age);//30
			}
		}
		//The type Zi cannot subclass the final class Fu
		//final class Fu{
		class Fu{
		//The final field Fu.age cannot be assigned
			final int age = 10 ;
			public static final int SUM = 10 ;
			
			public void eat(){
				System.out.println(1);
			}
		//Cannot override the final method from Fu
			final public void name(){
				System.out.println(2);
			}
		}
		class Zi extends Fu{
			public void eat(){
				System.out.println(10);
			}
			
		}

四、多态

4.1 概述

是指一个对象,具有多个形态
好处是:提高程序的通用性,灵活性.统一性

4.2 口诀

前提是:继承 + 重写

    口诀1:父类引用 指向 子类对象
			Animal a = new Dog();//多态
	口诀2:编译看左边,运行看右边	
			编译看左边-只能用父类提供的功能
			运行看右边-指结果以子类为准	

4.3 入门案例

代码如下（示例）：

//测试多态

public class Test05 {
	public static void main(String[] args) {
		// 创建子类对象测试
		// 子类能用 父类继承来的，还有自己扩展的
		dog x = new dog();
		x.show();//父类的
		x.eat();//重写了，用了子类的方法体
		x.sleep();//自己扩展的
		
		System.out.println("\t");
		
		//TOOD 创建多态测试对象
		//口诀1： 父类引用 指向子类对象
		Animal a = new dog();//多态
		//口诀2： 编译看左边，运行看右边
		//好处：统一调用标准，父类就是标准
		a.eat();//重写了就执行子类的方法体
		a.show();//没重写，执行父类的方法体
		//a.sleep();子类特有的方法，不能用
		System.out.println();
		
	}

}
class Animal{
	public void eat(){
		System.out.println("吃饭");
	}
	public void show(){
		System.out.println("djshfg");
	}
}

//子类一般都是方法重写，很少扩展
class dog extends Animal{
	public void sleep(){
		System.out.println("睡觉");
	}
	@Override //注解
	public void eat(){
		System.out.println("啃骨头");
	}
}

五、多态的使用

5.1 特点

1、成员变量：使用的是父类的

2、成员方法：由于存在重写现象所以使用的是子类的

3、静态成员：随着对象而存在，谁调用的就返回谁的

5.2 好处

—让程序通用性更强.多态里,把子类当父类来看,屏蔽了子类间的不同.
—统一调用的标准,向父类看齐

5.3 入门案例

代码如下（示例）：

//使用多态
//总结
//1.多态用来 统一调用标准，标准是父类
//2.创建对象的口诀：父类引用 指向 子类对象
//3.使用对象的口诀： 编译看左边，运行看右边
//4.非要用子类特有的---直接创建子类对象
public class Test06 {
	public static void main(String[] args) {
		//TOOD 创建多态对象测试
		fa x = new son();//多态/向上造型
		x.name();//方法声明---父类的 ；方法体---子类的
		System.out.println(x.age);//成员变量---父类的
		
		//TODO 静态方法可以被重写吗?---不能，都是用父类的
		x.eat();
		// TODO 子类扩展的，多态对象根本不让用，怎么办？---直接创建子类对象
	}
}
// 多态前提：继承+重写
class fa{
	int age = 10;
	public  void name () {
		// TODO Auto-generated method stub
		System.out.println("Javc");
	}
	public static void eat(){
		System.out.println(1534);
	}
}
class son extends fa{
	int age =45;
	@Override //注解
	public void name(){
		System.out.println("xxh");		
	}
	//不是重写，只是子类的扩展方法
	public static void eat(){
		System.out.println(44444);
		
	}
}

六、异常

6.1 概述

程序中出现的bug

6.2 异常的继承结构

Throwable - 顶级父类
-- Error：系统错误，无法修复
-- Exception：可修复的错误（程序中 bug 的父类）
   --RunTimeException
   --ClassCastException
   --ClassNotFoundException

6.3 异常的处理

1. —捕获:自己把异常处理掉

      try{
      	有可能出问题的代码
      }catch(异常的类型 变量名){
      	处理方案
      }catch(异常的类型 变量名){
      	处理方案
      }
   

2.—抛出:自己不管,交给调用者处理
在方法声明上加一段代码: throws 异常类型1,异常类型2
例如：

public static void main(String[] args)  throws Exception{

6.4 入门案例

代码如下（示例）：

//测试 异常的处理
public class Test07 {
	public static void main(String[] args) {
		//method();//暴露异常
		method2();//捕获异常
	}
	public static void method2() {
		// TODO Auto-generated method stub
		try {
			System.out.println("请输入两位整数：");
			int i = new Scanner(System.in).nextInt();
			int x = new Scanner(System.in).nextInt();
			System.out.println("做除法运算得："+i/x);
			
		} catch (ArithmeticException e) {
			System.out.println("输入的分母不能为0！");
			// TODO: handle exception
		} catch (InputMismatchException e) {
			System.out.println("请输入的数字类型为整数类型");
			// TODO: handle exception
		}
	}
	
	//暴露异常
	/*public static void method() {
		// 接受用户输入的两位整数，做除法
		System.out.println("请输入两位整数：");
		int i = new Scanner(System.in).nextInt();
		int x = new Scanner(System.in).nextInt();
		System.out.println("做除法运算得："+i/x);
	}*/	

	
//下面这些是暴露异常运行时出现的报错，可以根据错误信息来捕获异常
	
	/**Exception in thread "main" java.lang.ArithmeticException: / by zero
		at day04.Test07.method(Test07.java:16)
		at day04.Test07.main(Test07.java:8)*/
	
	/**	Exception in thread "main" java.util.InputMismatchException
		at java.util.Scanner.throwFor(Unknown Source)
		at java.util.Scanner.next(Unknown Source)
		at java.util.Scanner.nextInt(Unknown Source)
		at java.util.Scanner.nextInt(Unknown Source)
		at day04.Test07.method(Test07.java:15)
		at day04.Test07.main(Test07.java:8)*/
		  
	/**	Exception in thread "main" java.util.InputMismatchException
		at java.util.Scanner.throwFor(Unknown Source)
		at java.util.Scanner.next(Unknown Source)
		at java.util.Scanner.nextInt(Unknown Source)
		at java.util.Scanner.nextInt(Unknown Source)
		at day04.Test07.method(Test07.java:14)
		at day04.Test07.main(Test07.java:8)*/
	
	
	

}

---

总结

以上就是今天所学的内容，关于异常还有一点内容留到明天，加油！