Day03（对象和异常）

标题面向过程&面向对象

面向过程：

处理简单问题 ，步骤清晰

面向对象：

分类处理的思想 ， 处理复杂问题， 先分类后再面向过程思考
面向对象编程的本质：以类的方式组织代码，以对象的方式组织（封装）数据。
**抽象：**抽取共同点造成类
三大特性：

• 封装
• 继承
• 多态

类和对象

基础总结：

//1.一个类即便什么都没有，也有一个无参构造方法。但只要有一个构造方法，就没有默认的无参构造方法。
//2.构造器的做用 
// 实例化初始值 ：
//使用new关键字，本质是在调用构造器
//3.类是一个模板：抽象，对象是一个具体的实例
//4.对象的引用：
//引用类型（基本类型8个）
//对象是经过引用来操做的：栈---->堆
//5.对象的属性：字段Field 成员变量
//默认初始化：
//数字： 0 0.0
//char：u0000
//boolean： false
//引用：null

封装（高内聚，低耦合）

• 属性私有 ，使用公有的 get/set进行调用

继承

• 子类 extends 父类
• 快捷键：Ctrl+H 显示继承树
• Java中全部的类都默认直接或间接继承object类
• Java中只有单继承没有多继承（一个儿子只能用一个爸爸，一个爸爸能够有多个儿子）

多态

• 动态编译：

//一个对象的实际类型是肯定的
//能够指向的引用类型就不肯定了
Student s1=new Student();
Person s2=new Student();  //经过父类能够定义子类。父类能指向子类，不能调用子类独有的方法
Object s3=new Student();
//对象能执行哪些方法，看对象左边的类型
//子类重写了父类的方法，执行子类的方法

• 多态注意事项：
  1.多态是方法的多态，属性没有多态
  2.父类和子类有联系 注意：类型转换异常 ClassCastException
• Instanceof
  用于判断包含关系。

public static void main(String[] args) {
        //Object>Person>Teacher
//Object>Person>Student
        Object object=new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

• 类型转换
• 父类能够强制转换为子类。向下转型
• 父类引用指向子类对象
• 子类转换为父类可能丢失一部分原本的方法。向上转型。
• 方便方法调用，减小重复代码。

static特殊用法

1.代码块

public static void main(String[] args) {
Student student1=new Student();
System.out.println("+++++++++++++++++++");
Student student2=new Student();
    }
      { System.out.println("匿名代码块"); }//赋初值
static{ System.out.println("静态代码块"); }//只执行一次

    public Student() { System.out.println("构造方法"); }

输出顺序：

最早执行，仅执行一次

2.静态导入包

import  static  java.lang.Math.random;
double a=random；//等价于 double a=Math.random();

抽象类

//abstract 抽象类的定义
public abstract class Action {
    //约束 ~ 有人帮咱们实现
    //abstract 只有方法的名字，没有方法的实现
    public abstract void doSomething();
    //1.不能new抽象类，只能靠子类去实现它：约束！！！
    //2.抽象方法必须在抽象类中~ 抽象的抽象：约束
    
}

public class A extends Action {
//抽象类的全部方法，继承它的子类必需要实现它~~
// 除非它的子类也是抽象类
    @Override
    public void doSomething() {
    }
}

接口

做用：

1. 约束做用
2. 定义一些方法让不一样人实现
3. public abract 在接口中定义抽象方法
4. public static final 在接口中定义常量
5. 接口不能被实例化；由于接口中没有构造方法
6. 用inplements 能够实现多个接口
7. 必须重写接口中的方法

- 代码示例：

//锻炼抽象思惟！！！
//interface定义的关键字，接口都须要有实现类
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);
}

//抽象类：extends
//类 能够实现接口 implements 接口
// 实现了接口的类，必须重写全部方法
//利用接口 实现Java中的伪多继承
public class UserServicelmpl implements UserService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

• 接口的本质是契约 ；
• 接口的声明关键字是 interface；

内部类

1.普通内部类

public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获取外部类的私有属性和私有方法
        public void getID(){
            System.out.println(id);
        }
    }
}
public class Applycation {
    public static void main(String[] args) {
        Outer outer=new Outer();
        //经过外部类来实例化内部类
      Outer.Inner inner=  outer.new Inner();
    }
}

2.静态内部类

//静态内部类优先于外部类中非静态部分执行。不能获取外部类的非静态元素
static   class  Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }      
    }
}

3.局部内部类
多个class类在同一文件，只有一个public为外部类。其余class叫局部内部类。
不用将实例保存到变量中，能够不用名字初始化类。了解就能够。

extends和implements

• extends 继承类；implements 实现接口。
• 类和接口是不一样的：类里是有程序实现的；而接口无程序实现，只能够预约义方法

异常机制

把异常看成对象来处理，用java.lang.Throwable为全部异常的超类

• 异常的处理机制：
  5个关键字：

try	划定监控区域 快捷键Ctrl+Alt+T
catch	捕获异常
finally	处理善后，能够不写。存放必定要执行的内容
throw	主动抛出异常，通常在方法中使用
throws	当方法中没法处理时，在方法上抛出异常

• 自定义异常：
  建立一个类来 继承Exception类

• 异常处理过程当中遇到的bug

  例题：
  在输入错误时，会无限次循环

public class ch12Q02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            try {
                System.out.print("please input 2 integers: ");
                int n1 = scanner.nextInt();
                int n2 = scanner.nextInt();
                System.out.println(n1 + " + " + n2 + " = " + (n1 + n2));
            } catch (InputMismatchException ime) {
                System.out.println("input wrong number.");
            }
       }
    }

解决方法：把scanner提进去