JAVA06

多态

• 动态编译：类型 可拓展性更强
• 一个对象实际类型的确定的 引用类型不确定
• Person a=new Student();
• Studen b=new Student();
• Object c=new Student();

public class Person {public void eat(){System.out.println("eat");}}public class Student extends Person{@Overridepublic void eat() {System.out.println("s");}public void run(){System.out.println("run");}}public class Main {public static void main(String[] args) {Student student=new Student();Person person=new Student();Object object=new Student();//person.run();((Student)person).run();//高转低//子类可以调用父类的方法重写后调用子类的//类型是父类没有的方法不能调用子类的方法}
}

1. 多态面向的是方法 属性和字段没有方法
2. 父类和子类之间有关系 类型转换异常 ClassCastException
3. 首先得有继承关系 存在复写
4. 父类引用指向子类

• Static 与类不能
• Finall不能
• private也不能重写

instanceof 类型转换

// x instanceof y->存在父子关系
public class Main {//Object//Object>Person>Studenpublic static void main(String[] args) {Object object = new Student();System.out.println(object instanceof  Object);//trueSystem.out.println(object instanceof Student);//trueSystem.out.println(object instanceof Person);//trueSystem.out.println(object instanceof String);//falseStudent object1 = new Student();System.out.println(object1 instanceof  Object);//trueSystem.out.println(object1 instanceof Student);//trueSystem.out.println(object1 instanceof Person);//true//System.out.println(object instanceof String);//false同节无法比较}
}

• 类型转换 父类高 只类低 低转高是自动完成的 高转低要i强制转换

• 子类转父类可能会丢失一些方法

• 父类指向子类对象

• 子类->父类向上

• 父类 子类 向下强制转换

• 抽象的思想

Static

• 静态方法
• 静态属性

package com.kangsdan.Base.zcj;public class Demo07 {private static int age;//静态private double score;//非静态public void say(){System.out.println("say");}public static void run(){System.out.println("run");}public static void main(String[] args) {new Demo07().say();//非静态调用Demo07.run();//静态调用Demo07 student=new Demo07();System.out.println(student.score);System.out.println(student.age);System.out.println(Demo07.age);//静态变量 共享//System.out.println(Demo07.score);}
}

静态方法 静态代码块 构造方法

package com.kangsdan.Base.zcj;public class Demo {{//可以给初始值System.out.println("匿名代码块");//代码块}static {//只执行一次System.out.println("静态代码块");//静态代码块}public Demo(){System.out.println("构造方法");}public static void main(String[] args) {new Demo();System.out.println("***************");new Demo();}
}

• 静态导入包

import static java.lang.Math.random;//静态导入包
public class Dem0{public static void main(String[] args) {System.out.println(random());}
}

• final 无法继承

抽象类

• abstract

public abstract class Action01 {//抽象类//约束 有人帮实现//只有方法名没有方法提//继承就必须重写//不能new出来//只能靠子类复写public abstract void doSomthing();
}

• 接口可以实现多继承（Java没有多继承

• public abstract class Action01 {//抽象类//约束 有人帮实现//只有方法名没有方法提//继承就必须重写//不能new出来//只能靠子类复写//抽象的方法可以有普通的类//抽象的类必须在抽象的方法public abstract void doSomthing();
  }//提高开放效果
  

• 关于抽象类有没有构造器 连接、

以举例的方式说到如何区分抽象类和接口，这里我们从Java语法谈起，使我们更加了解这两者的内在区别。它们的语法区别：
1）接口不能有构造方法，抽象类可以有。
2）接口不能有方法体，抽象类可以有。3）接口不能有静态方法，抽象类可以有。4）在接口中凡是变量必须是public static final，而在抽象类中没有要求。
————————————————
版权声明：本文为CSDN博主「lllllzllll」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_40728375/article/details/79890223

接口

• 普通类 只有具体的实现
• 抽象类 具体 和抽象方法
• 接口 只有规范 没有自己的方法 专业的约束 约束和实现分离
• 接口的本质是契约

package com.kangsdan.Base.Demo09;public interface TimeServeers {//属性都是常量  fianl static publicint age =99;void timeSet();
}public interface UserService {//接口中所有的东西都是抽象的 publicvoid add(String name);void delet(String name);
}package com.kangsdan.Base.Demo09;
//实现接口的类必须重写方法
public class UserServiceImpl implements UserService ,TimeServeers{@Overridepublic void add(String name) {}@Overridepublic void delet(String name) {}@Overridepublic void timeSet() {}
}//架构的创建系统 就是用接口定义框架

• 总结

1. 约束
2. 定义方法 不同实现
3. 方法类型 public abstract
4. 属性 public static fianl
5. 不能被实例化 没有构造方法
6. 可以实现多个接口，必须要重写接口的方法

内部类

• 定义在类内部类

1. 成员内部类
2. 静态内部类（加static
3. 局部内部类（方法内定义的
4. 匿名内部类[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lDK3nY5Y-1591358636175)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200601111914445.png)]

package com.kangsdan.Base.Demo10;public class Outer {private int id;public void out(){System.out.println("out");}public class Inner{public void inter(){System.out.println("inner");}}}package com.kangsdan.Base.Demo10;public class Appliction {public static void main(String[] args) {Outer outer=new Outer();outer.out();//外部类实例化内部类Outer.Inner inner=outer.new Inner();inner.inter();}
}
//可以获取外部类的私有属性 
//一个java 类可以有多个class 只可以有一个public

异常机制

• Exception
• 文件打开 内存
• 检查性异常 打开不存在的文件夹
• 运行时候异常 在编译时可能被忽略
• 错误 错误不是异常 ERROR堆栈溢出 编译找不到（虚拟机 与程序无关 是虚拟机导致的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EodEB6Ph-1591358636179)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200601154023543.png)]

ArithmeticException：算数异常

public class T1 {public static void main(String[] args) {int a=1;int b=0;try {//监控区域System.out.println(a/b);}catch (ArithmeticException e){//捕获异常System.out.println("你输入的数据存在就算错误");System.out.println(e);}finally {//终究会被执行System.out.println("处理完成");}
//System.exit(0);}
}//快捷键 ctrl+alt+t

throw(s)

public class Test2 {public static void main(String[] args) {int a=10;int b=0;if(b==0){throw new ArithmeticException();//主动抛出异常}}public void test()throws Exception{}
}

自定义异常

• package com.kangsdan.Base.Exception;
  //自定义的异常类
  //双击shfit 就可以搜索类
  public class MyException extends Exception{
  //传递数值》10private int detal;public MyException( int detal) {this.detal = detal;}@Overridepublic String toString() {return "MyException{" +"detal=" + detal +'}';}
  }

package com.kangsdan.Base.Demo11;public class T1 {public static void main(String[] args) {int a=1;int b=0;try {//监控区域System.out.println(a/b);new T1().a();}catch(ArithmeticException e){//先小后大否者会被覆盖System.out.println("a");}catch (Throwable e){//捕获异常//增加处理异常的代码块System.out.println("你输入的数据存在就算错误");System.out.println(e);}finally {//终究会被执行System.out.println("处理完成");}}public void a(){a();}public void b(){b();}
}

经验总结

• 规避和辅助 try—catch
• 多重catch最后写一个最大的异常
• 不确定的代码 加上try catch又可以避免
• 处理异常而不是简单的输出
• 根据业务的需求区确定异常的
• 最后用fianlly来释放占用的资源
• //alt+enter可以提示