java面向对象60-76

面向对象

• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

三大特性
1.封装
2.继承
3.多态

类与对象的关系

• 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物
• 对象是抽象概念的具体实例

类的实例化

//student对象就是Student类的具体实例
Student xiaohong=new Student()
Student xiaoming=new Student()

类的属性和字段

public class Student{
//属性：字段
String name;
int age

构造器

1.和类名相同
2.没有返回值

功能

1.使用new关键字必须要有构造器
2.用来初始化值
//alt+inset会生成构造器

封装（高内聚，低耦合）

私有

• private(不可调用）
• set可以赋值私有属性
• get可以获取私有属性

//main
package com.shy.operator;

public class demo1 {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("shy");
        System.out.println(s1.getName());
        s1.setAge(999);
        System.out.println(s1.getAge());

    }
}
//Student类
package com.shy.operator;

public class Student {
    private String name;
    private int id;
    private char sex;
    private int age;
    public String getName(){
        return this.name;
}
    public void setName(String name){
        this.name=name;
    }
    public int getId(){
        return id;
    }
    public void setId(int id){
        this.id=id;
    }
    public char getSex(){
        return sex;
    }
    public void setSex(char sex){
        this.sex=sex;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        if (age>120||age<0){
            this.age=3;
        }else{
            this.age=age;
        }
    }
}

继承

//父类
//java中，所有的类都继承Object类
public class Person {
    public int money=10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
}
public class Student extends Person{
    //子类继承了父类，就会有父类的全部方法
    //私有无法继承

super

super.name(即可以调用父类中的属性）
super（）调用父类的构造器必须在子类的第一行

方法的重写

1.非静态
2.public
3.方法名必须相同
4.参数列表必须相同
5.修饰符范围可以扩大但是不能缩小：public<Protected<Default<private

多态

• 父类的引用指向子类
• 父类形，可以指向子类，但不能调用子类独有的方法
• 多态是方法的多态，不是属性

instanceof

import com.shy.operator.demo2.Person;
import com.shy.operator.demo2.Teacher;

public class Application {

public static void main(String[] args) {
        //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
    }
}

类型的转换

• 低转高可以直接转Person student= new Student();
• 高转低要强制转换可能会丢失一些方法

static关键字

• final之后不能继承
• static静态代码块是最早执行的

抽象类

• abstract只有方法名字，没有方法的实现
• 不能new这个抽象类，只能靠子类去实现他的约束
• 抽象类中可以写普通的方法
• 抽象方法必须在抽象类中

接口

• 声明接口的关键字是interface
• 内部默认就是public
• implements 可以多继承

内部类

1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类

• new Apple().eat() 没有名字初始化类不用讲实例保存到变量

异常机制

1.检查性异常
2.运行时异常
3.错误

• java把异常当做对象处理，定义一个基类java.lang.Throwable作为所有异常超类
  -异常类被分为两大类，错误Error,异常Exception.
  
  

异常处理机制

• 抛出异常
• 捕获异常

异常处理五个关键字

1.try
2.catch
3.finally
4.throw
5.throws

public class demo1 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try{//try监控区域
            System.out.println(a/b);
        }catch(ArithmeticException e){//catch 捕获异常 catch（想要捕获的异常类型）
            System.out.println("程序出现异常，变量b不能为0");
        }finally {//处理善后工作
            System.out.println("finally");
        }
        }
}

• 捕获异常要从小到大
• throw主动抛出异常

• 自定义异常类