Java基础-day08-static·static静态代码块·final 关键字·多态·汽车设计综合案例·异常

day09

1.static

是java中的一个关键字
用于修饰成员（成员变量和成员)
1.static是一个关键字
2.static可以修饰成员变量和方法，被修饰的资源就是静态资源
3.静态资源优先于对象加载，随着类的加载而加载
4.被静态修饰的资源可以通过类名直接调用
//Student.name
//Student.speak();
5.静态资源全局共享(被所有对象共享)，值只有一份
静态的调用关系：
1.静态资源只能调用静态资源*****
2.非静态资源既可以调用静态资源，也调用非静态资源方法）

//静态资源可以通过类名直接调用，无需创建对象
/*静态资源优先于对象进行加载，随着类的加载而加载
* 比对象优先加载到内存，没对象时也可以通过类名直接调用
* */

package cn.tedu.oopextends.cn.tedu;
//测试静态的案例
public class oopstatic {public static void main(String[] args) {//静态资源可以通过赖明直接调用，无需创建对象/*静态资源优先于对象进行加载，随着类的加载而加载* 比对象优先加载到内存，没对象时也可以通过类名直接调用* */System.out.println(Student.name);//System.out.println(Student.sno);Student.speak();Student s = new Student();Student s2 = new Student();s.name = "周瑜";System.out.println(s2.name);s2.name = "黄桃罐头";//静态资源被全局所有对象共享，值只有一份System.out.println(Student.name);System.out.println(s.name);System.out.println(s2.name);s.study();}
}
//通过抽象封装形成一个学生类
class Student{//创建属性--成员变量--无须手动初始化/*1.可以通过static将普通资源修饰成静态资源* 2.static可以用来修饰成员变量和方法，一般写在修饰符的后面*/static String name;int sno;public void study(){System.out.println("不过了");}//将speakstatic public void speak(){System.out.println("大声讲出来");}
}

2.static静态代码块

1.格式： static{ }
位置：类里方法外
执行时机：随着类的加载而加载，优先于对象加载，并且只加载一次
作用：用于加载一些需要第一时间就加载并且只加载一次的资源

2.构造代码块
位置：类里方法外，格式{ }
执行时机：创建时触发，优先于构造方法之前执行
作用：用于提取所有构造方法的共性功能

3.局部代码块
位置：方法里，格式：{ }
执行时机：调用当前所处方法时才触发
作用：用来控制变量的作用范围，变量的作用范围越小越好

4.执行顺序：
静态代码块->构造代码块->构造方法【创建好对象】->调用普通方法中（有局部代码块）

5.为什么这样的顺序？
静态代码块也是静态资源，静态资源随着类的加载而加载，优先于对象的创建，静态资源只加载一次，并且一直存在，直到类消失，它才会消失

package cn.tedu.block;
//测试代码块之间的关系
public class TestBlock {public static void main(String[] args) {/*在创建对象之前，会先自动执行静态代码块，而且此静态代码块只执行一次* 每一次创建对象时，都会调用构造代码块与构造方法，构造代码块先执行*/Person p = new Person();Person p2 = new Person();//p对象执行了静态代码块/*当对象调用方法时，如果方法里有局部代码块局麻代码块才会被执行* */p.sleep();}
}
class Person{/*静态代码块：位置：类里方法外触发时机：静态代码块也是静态资源，随着类的加载而加载，优先于对象加载，而且此静态代码块只执行一次作用：用于完成一些需要第一时间就加载的资源*/static {System.out.println("此处为静态代码块");}/*构造代码块：位置：类里方法外触发时机:创建对象是触发，而且要优先于构造方法执行作用：用于提取所有构造方法的共性功能*/{System.out.println("构造代码块");}/*构造方法：* 是与类同名且没有返回值类型的方法，用于创建对象，在创建对象时触发*/public Person(){System.out.println("构造方法");}public void sleep(){System.out.println("普通方法");/*局部代码块位置：方法里执行时机：调用本方法时触发作用：用啦控制变量的作用范围，变量的作用范围越小越好*/{System.out.println("我是局部代码块");}}
}

3.final 关键字

1.被final修饰的类是最终的类，不可以被继承
2.被final修饰的方法是方法的最终实现，不可以被重写
3.被final修饰的变量变成常量，值不可以被修改
*声明常量时必须给常量赋值，不赋值会报错

package cn.tedu.block;public class TestFinal {public static void main(String[] args) {Son s = new Son();s.work();s.workOld();//s.name = "干饭人";System.out.println(s.name);}
}
/*1.final表示最终，可以用来修饰类但是被final修饰的类无法被继承，也就是没有子类，他自己就是最终类*/
//final class  Father{:报错：Son类不能继承被final修饰的Father类
class  Father {//final 可以用来修饰成员=变量，被Final修饰的变量值不可以被修改//注意！！！常量在定义时候就需要赋值，否则就报错String name = "打工人";//final 可以用来修饰方法，被final修饰的方法是方法的最终实现，不能被重写public void work() {// final public void work()}
}class Son extends Father {public void workOld() {super.work();}@Overridepublic void work() {System.out.println("Son ..现在的打工人，都用计算机打工");}}

4.多态

1.概念

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

2.小结
继承+重写
口诀1：父类引用指向子类对象
口诀2：编译看左边，运行看右边
如果想要使用多态的效果，方法的声明看的是父类，而具体实现使用的是子类，我们目前学习的多态都是把自己当作是一个父类类型，所以：
1）多态对象不可以使用子类特有的功能
2）多态对象使用成员变量是父类的
3）多态对象使用时，如果父子类出现静态同名静态方法，使用的是父类的
4）多态对象在使用方法时，如果父子类重写了，使用的是子类的方法体

*静态资源属于优先加载的类资源，静态方法不存在重写的现象

package cn.tedu.oop;
//本类多态中元素的测试
public class TestDemo2 {public static void main(String[] args) {Cat2 c = new Cat2();System.out.println(c.sum);//100c.eat();//子类重写，调用子类的c.play();/*口诀1：父类引用 指向子类对象* 口诀2:编译看左边 运行看右边* */Animal2 a = new Cat2();System.out.println(a.sum);//10a.eat();/*多态中，如果父子类有同名的静态方法，使用的是父类的* 因为多态对象被看做是父类类型*/a.play();}
}
class Animal2{int sum = 10;public void eat(){System.out.println("吃点东西吧");}public static void play(){System.out.println("去玩地球");}}
/* 多态的前提是：继承+重写*/
class Cat2 extends Animal2 {int sum=100;@Override//父类功能重写public void eat(){System.out.println("给猫吃点");}//普通方法/*注意：静态资源属于类，不存在重写的现象，* 只是两个类中恰好有两个同名的静态方法而已*/public static void play(){System.out.println("小猫去玩球");}
}

5.汽车设计综合案例

package cn.tedu.design;
//OOP汽车设计
public class Designer {public static void main(String[] args) {Car c = new Car();System.out.println(c.getColor());//null,c.start();//父类自己的功能c.stop();//父类自己的功能//c.fly();//父类调用不了子类的功能//子类对象BWM b = new BWM();System.out.println(b.color);//绅士黑b.start();//调用父类的start功能b.stop();//调用父类的stop功能//子类对象BSJ b2 = new BSJ();System.out.println(b2.getColor());//nullb2.fly();//调用自己的方法}
}
class Car{//属性--成员变量//封装---关键字privated对属性进行封装String brand;String color;double price;double size;//行为--通过方法public void start(){System.out.println("q启动");}public  void stop(){System.out.println("车熄火了");}//封装属性public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}public double getSize() {return size;}public void setSize(double size) {this.size = size;}
}
//宝马类class BWM extends Car{String color ="绅士黑";//重写 --两同两小一大@Overridepublic  void stop(){System.out.println("BWM停的更稳了");}
}class BSJ extends Car{String color = " 亮白 ";public void fly() {System.out.println("加速度是我的脚步，飞");}}

6.异常

由异常类型、提示信息、报错的行号提示组成

**异常的继承结构

Throwable --异常的顶级父类
Error–系统异常，不可解决
Exception—可编程解决的异常
编译时异常–括号写错了，压根就通不过编译
运行时异常–RunTimeException–InputMismatchException

**异常处理方案

1.捕获处理
try{
可能会错的代码
}catch（异常类型异常的名字）{
捕获到异常的处理方案
}
** Catch 可以嵌套，一般写一个Exception 做通用解决方案就可以
2.向上抛出
格式：在方法定义的两个括号之间加一个throws 异常类型
如果有多个异常，可以使用都好隔开
注意：如果方法抛出异常，谁调用这个方法，谁就得处理【捕获/抛出】
不能把异常抛给main()，需要在main()调用之前解决掉

package cn.tedu.exception;import java.util.InputMismatchException;
import java.util.Scanner;//测试异常
public class ExceptionDemo {public static void main(String[] args) {// method();// 人为暴露异常// method2();//异常解决方案1//method3();//异常解决方案2---向上抛出f();//标准写法，向上抛出}private static void f() {try{method3();}catch(Exception e){System.out.println("请输入请正确数据：");}}/*如果一个方法抛出了异常，那么谁调用这个方法，谁就需要出库这个异常这里处理也有两种方案：捕获解决和向上抛出注意：我们一般会在main（）调用之前解决掉异常而不是把问题抛给main（），因为没人解决了，详见本类f（），调用method*/private static void method3() throws InputMismatchException,ArithmeticException {System.out.println("输入第一个整数：");int a = new Scanner(System.in).nextInt();System.out.println("请输入第二个整数：");int b = new Scanner(System.in).nextInt();System.out.println(a/b);}/*异常捕获处理的格式* try{*   可能会抛出异常的代码* }catch（异常类型 异常名字）{*    匹配到了错误，进行处理的解决方案* }* */private static void method2() {//捕获处理异常解决方案/*如果发生异常，会被catch捕获，执行之前catch中提供的解决方案*/try{System.out.println("输入第一个整数：");int a = new Scanner(System.in).nextInt();System.out.println("请输入第二个整数：");int b = new Scanner(System.in).nextInt();System.out.println(a/b);}catch(InputMismatchException e){//注意导包System.out.println("请输入规定的整数类型！");}catch(ArithmeticException e){System.out.println("除数不能为0，请重新输入！");}catch(Exception e){System.out.println("您输入的不对！请重新输入！");}/*这就是多态中经典的，我们并不关心子类具体的类型而是*/}private static void method() {//提示并接收用户的    InputMismatchException输入不匹配异常///       ArithmeticException: / by zero 算术异常，分母不能为0System.out.println("输入第一个整数：");int a = new Scanner(System.in).nextInt();System.out.println("请输入第二个整数：");int b = new Scanner(System.in).nextInt();//直接打印这两个数除法的结果System.out.println(a/b);}
}