JAVA构造器、面向对象三大特征、instanceof、接口、捕获和抛出异常

构造器

1.和类名相同

2.没有返回值

作用

1.new本质在调用构造方法

2.初始化对象的值

定义有参构造之后，如果使用无参构造，显示的定义一个无参的构造

alt+insert快捷添加

this.

一个类即使什么都不写，他也会存在一个方法

有参构造：一旦定义了有参构造，无参构造必须显示定义

---

1.类与对象

类是一个模板：抽象，对象是一个具体的实例

2.方法

定义、调用！

3.对应的引用

引用类型： 基本类型（8）

对象是通过引用来操作的：栈--->堆

4.属性：字段Field 成员变量

默认初始化：

数字：0 0.0

char： u000

boolean： false

引用：null

修饰符 属性类型 属性名 = 属性值

5.对象的创建和使用

-必须使用new 关键字创建对象，构造器

-对象的属性

-对象的方法

6.类

静态的属性 属性

动态的行为 行为

---

面向对象三大特征：封装、继承、多态

封装

属性私有：get/set

在类中用private 修饰属性，属性私有

private String name;

如何调用私有属性呢？

提供一些可以操作这个属性的方法。

//get 获得这个数据
public String getName(){
    return this.name;
}
​
//set 给这个数据设值
public void setName(String name){
    this.name = name;
}

alt+insert 自动生成get/set方法

为什么要封装呢？

1.提高程序的安全性，保护数据

2.隐藏代码的实际细节

3.统一接口

4.增加了系统可维护性

可以通过在get/set方法内部添加一些功能，来检验数据。

列如，设置了一个私有属性年龄，如果年龄为999，则不符合实际，于是我们可以通过在方法内添加检验来避免错误数据。

public void setAge(int age){
    if(age>120||age<0){
        System.out.println("输入年龄有误！");
    }else{
        this.age = age;
    }
}

继承

extends的意思是“扩展”。子类是父类的扩展。

java中类只有单继承，没有多继承。（一个儿子只能用一个爸爸，但是一个爸爸可以有多个儿子。）

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

子类和父类之间，从意义上来讲应该有“is a"的关系。

public class person(){
}
//student is person
public class student extends person(){
}

子类继承了父类，就会拥有父类的全部方法

私有属性无法继承

私有属性同样可以通过get/set继承

java中所有的类都默认直接或者间接的继承object

super：

1.调用父类构造方法，必须在构造方法的第一个

2.super必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法

代表的对象不同

this：本身调用者这个对象

super：代表父类对象的应用

前提：

this：没有继承也可以使用

super：只能在继承条件才可以使用

构造方法：

this()；本类的构造

super()；父类的构造！

方法的重写

子类重写父类的方法，需要有继承关系

条件：

1.方法名必须相同；

2.参数列表必须相同；

3.修饰符： 范围可以扩大但不能缩小； public> protected>default>private

4.抛出的异常： 范围，可以被缩小，但不能扩大：ClassNotFoundException-->Exception(大)。

不能被重写的方法

static 方法，静态的，属于类，不属于实例

final 常量

private 方法，

为什么需要重写

父类的功能不一定需要或者不一定满足

多态

同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

public class Person {
    public void run(){ }
}
public class Student extends Person {
        @Override
        public void run(){
            System.out.println("son");
        }
​
        public void eat(){
            System.out.println("eat");
        }
​
}
public class Test5 {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
​
        //可以指向的引用类型就不确定了：父类的引用指向子类
​
        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        
        //方法哪个类型的就执行哪一个
        //如果子类父类中都有该方法，则执行子类的
​
        s2.run();//son
        ((Student) s2).eat();//eat
        //s2.eat无法直接使用，因为s2的类Person中没有eat方法
        //所以需要将s2的Person强制转换为Student
        s1.eat();//eat
    }
}

多态注意事项：

1.多态是方法的多态，属性没有

2.父类和子类，有联系 关系异常 ClassCastException

3.存在的条件： 继承关系，方法需要重写，父类引用指向子类对象 father f1 = new Son();

Instanceof

它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

public class Application {
    public static void main(String[] args) {
​
        //Object > String
        //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
        //当没有父子关系的时候，编译会报错！
​
    }
}

接口

接口中只有方法的定义

接口的定义

//通过interface来定义

public interface TimerService{
    void timer();
}
 

public interface UserService {
    //接口中的所有定义其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

实现类

interface定义的关键字，接口都需要有实现类

通过implements

实现了接口的类，就必须重写接口中的方法

通过implements连接多个接口实现了多继承

public class UserServiceImpl implements UserService,TimerService{
    @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(){
​
    }
}

捕获和抛出异常

int a = 1;
int b = 0;
​
try{//try监控区域
    System.out.println(a/b);
}catch (ArithmeticException e){//catch(想要捕获的异常类型)  捕获异常
    System.out.println("程序出现异常，变量b不能为0")；
}finally {//处理善后工作
    System.out.println("finally");
}

可以在中间添加多个catch捕获异常

但是异常类型应当层层递进的向下叠加，从小到大

选中要监控的区域，Ctrl Alt + T自动生成