Day07_java对象下
类型转换
- 父类引用指向子类的对象。
- 把子类转换为父类，向上转型，无需强制转换，但会丧失子类特有的方法。
- 把父类转换为子类，向下转型，强制转换。
- 方便方法的调用，减少重复的代码
static详解
静态变量调用
public class Student {
private static int age;
private double score;
public static void main(String[] args) {
Student s1=new Student();
System.out.println(Student.age);//静态变量通常使用这种调用方法
System.out.println(s1.age);
System.out.println(s1.score);
}
代码块
public class Student {
private static int age;
private double score;
{
//匿名代码块
System.out.println("匿名代码块");
}
static{
//静态代码块，首先被执行，只执行一次
System.out.println("静态代码块");
}
public Student() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Student s1=new Student();
System.out.println("=================");
Student s2=new Student();
}
}
输出：
静态代码块
匿名代码块
构造方法
=================
匿名代码块
构造方法
解释：静态代码块，首先被执行，只执行一次。匿名代码块在构造方法前执行。
静态导入包
import static java.lang.Math.random;
public class Demo01 {
public static void main(String[] args) {
System.out.println(random());
}
}
此时可以直接调用random方法。
注意
final类不能被继承。
抽象类
abstract 抽象类，只能单继承。（接口可以多继承）
抽象方法
- 约束，有人去实现
- 只有方法名，没有方法的实现
public abstract class Action {
public abstract void doSomething();
}
- 不能new这个抽象类，只能靠子类去实现它
- 抽象类中可以写普通的方法
- 抽象方法必须在抽象类中
new抽象类的子类后，该抽象类有构造器。
抽象类存在的意义：提高开发效率。
接口
声明关键字：interface
注意点
- 约束
- 定义一些方法，让不同的人去实现
- 方法的类型都是public abstract
- 常量的类型都是public static final
- 接口不能被实例化，接口内没有构造方法
- implements可以实现多个接口
- 必须要重写接口中的方法
//userService.java
public interface userService {
//接口中定义的是常量，public static final
int AGE=99;
//接口中定义的所有方法都是是抽象的，默认是public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
timeService.java
public interface timeService {
void timer();
}
//userServiceImpl.java
//类可以实现接口 implements 接口名称
//实现接口的类，需要重写接口中的方法
//利用接口实现多继承
public class userServiceImpl implements userService,timeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
成员内部类
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获取外部类的属性
public void getID(){
System.out.println("Id: "+id);
}
}
}
//一个java文件中可以有多个class类，但是只能有一个public class
class A{
}
public class test extends Outer{
public static void main(String[] args) {
Outer out = new Outer();
//通过外部类来实例化内部类
Outer.Inner inner=out.new Inner();
inner.getID();
}
}
输出：
Id: 10
静态内部类
public class Outer {
static private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public static class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//此时id会报错，这是由于id不是静态常量，将id前修饰符加上static即可
public void getID(){
System.out.println("Id: "+id);
}
}
}
public class test extends Outer{
public static void main(String[] args) {
Outer out = new Outer();
//通过外部类来实例化内部类，此时直接将Inner类实例化即可
Inner inner=new Inner();
inner.getID();
}
}
局部内部类
public class Outer {
publid void method(){
//局部内部类，不建议这样用
class A{
}
}
}
匿名内部类
public class test extends Outer{
public static void main(String[] args) {
//没有名字初始化类，不用将实例保存到变量中
new Apple().eat();
new UserService(){
@Override
public void Hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("eat");
}
}
interface UserService{
void Hello();
}
异常机制
- 抛出异常
- 捕获异常
异常处理5个关键字
- try
- catch
- finally
- throw
- throws
捕获异常
public class test {
public static void main(String[] args) {
int a = 1;
int b = 0;
//windows中crtl+alt+t快捷生成try
//Mac中Command+option+t快捷生成try
try { //try监控区域
new test().divide(a, b);
}catch (Error e){//捕获异常，括号内为想要捕获的异常类型
System.out.println("Error，b不能为0");
}
catch (Exception e){//捕获异常，括号内为想要捕获的异常类型
System.out.println("Exception，b不能为0");
}
catch (Throwable e){//捕获异常，括号内为想要捕获的异常类型
System.out.println("Throwable，b不能为0");
} finally{//处理善后工作
System.out.println("finally");
}
}
public void divide ( int a, int b){
System.out.println(a / b);
}
}
输出：
Exception，b不能为0
finally
主动抛出异常
public class test {
public static void main(String[] args) {
try {
new test().divide(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
} finally {
System.out.println("程序异常，b不能为0");
}
}
//假设在这个方法，处理不了这个异常。方法上抛出异常用throws
public void divide(int a, int b) throws ArithmeticException{
if (b==0){//方法内抛出异常用throw
System.out.println("程序异常，divide抛出异常");
throw new ArithmeticException();//主动抛出异常，一般在方法中使用
}
}
}
输出：
程序异常，divide抛出异常
程序异常，b不能为0
java.lang.ArithmeticException
at com.shan.oop.test.divide(test.java:17)
at com.shan.oop.test.main(test.java:6)
自定义异常
//MyException.java
public class MyException extends Exception{
private int detail;
public MyException(int a){
this.detail=a;
}
//toString:异常的打印信息
@Override
public String toString() {
return "MyException{" + detail +
'}';
}
}
//test.java
public class test {
public static void main(String[] args) {
try {
test(1);
test(11);
test(5);
} catch (MyException e) {
System.out.println("MyException==>"+e);
}
}
//可能会存在异常的方法
static void test(int a) throws MyException{
System.out.println("传递的参数为： "+a);
if(a>10){
throw new MyException(a);//抛出异常
}
System.out.println("OK");
}
}
输出：
传递的参数为： 1
OK
传递的参数为： 11
MyException==>MyException{11}
test（5）未运行，这是由于test（11）抛出异常后，被catch捕获，跳过test（5）。
实际应用中的经验总结
- 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
- 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
- 对于不确定的代码，也可以加上try-catch，处理潜在的异常
- 尽量去处理异常，切忌只是简单地调用printStackTrace（）去打印输出
- 具体如何处理异常，要根据不同的业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源
总结
今天看完了java零基础入门的最后一节课，对java知识有了更清晰的了解，之前的很多疑惑也明白了。如果基础不好，想学习java，强烈推荐b站上狂神说java的视频,静下心来慢慢看，学而时习之，不亦乐乎？坚持下来肯定会有收获！明天开始学习网络编程的知识，坚持就是胜利！加油！