java基础02

什么是面向对象

• 面向对象编程（Object-oriented Programming, OOP）

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

• 抽象：编程思想！

• 三大特性：封装、继承、多态

方法

• 静态方法可以直接用类名.方法名()直接调用，非静态方法需要先实例化。

• 静态方法和类是一起加载的，非静态方法在类实例化之后才存在。

public class Demo{
    public static void main(String[] args){
    	...    
    }
    
    //静态方法和类一起加载的
    public static void a(){
        b(); //报错,如果a方法的static去掉就不会报错
    }
    
    //非静态方法在类实例化之后才存在
    public void b(){
        ...
    }
}

类与对象

• 类是一种抽象的数据类型，它是对某一类事务整体描述/定义，但并不能代表一个具体的事务。

• 对象是抽象概念的具体实例。

• 使用new关键字创建对象。

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器（构造方法）的调用。

• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：（1）必须和类的名字相同（2）必须没有返回类型，也不能写void

public class Person{
    String name;
    //一个类即使什么都不写，它也会存在一个方法
    //无参构造 
    public Person(){
        this.name = "Brandon";
    }
    
    //有参构造：一旦定义了有参构造，无参就必须显式定义！！
    public Person(String name){
        this.name = name;
    }
    
    //方法的重载
    //构造器的快捷键:alt + insert（IDEA）
}

构造器：

1.和类名相同

2.没有返回值

作用：

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

2.初始化对象的值

注意点：

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

创建对象内存分析

https://www.bilibili.com/video/BV12J41137hu?p=65

java基础1中也有一定叙述。

• 对象是通过引用来操作的：栈 ---> 堆（地址） 引用类型

私有属性

public class Student{
    //属性私有
    private String name;
    private int id;
    private char sex;
    
    //提供一些可以操作这个属性的方法！
    //提供一些public的get、set方法
    
    //get获得这个数据
    public String getName(){
        return this.name;
    }
    
    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
}

• get和set方法可以使用alt + insert 然后选中getter and setter进行自动填充。

继承

• JAVA中类只有单继承，没有多继承！（一个爸爸可以又多个儿子，一个儿子只能有一个爸爸）

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

ctrl + H 可以查看类的继承关系（IDEA）

• 私有（private）的属性或行为无法被继承。

• 子类的构造方法里会自动调用父类的无参构造方法里的内容！

public class Student extends Person{
    public Student(){
        //隐藏代码：调用了父类的无参构造
        
        super();  //调用父类的构造器，必须在子类构造器的第一行。可以隐藏不写！
        ...
    }
}

super注意点：

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

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

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

重写

public class B{
    public void test(){  //无static，非静态方法
        System.out.printIn("B");
    }
}//父类

public class A extends B{
    public void test(){  //非静态(无static)才是重写！并且只能是public不能是private！
        System.out.printIn("A");
    }
}

public class Application{
    
    //A和B中的静态方法和非静态的方法区别很大！
    //静态方法，方法的调用只和左边，定义的数据类型有关！
    public static void main(String[] args){
        
        A a = new A();
        a.test();  //输出A
        
        //父类的引用指向了子类
        B b = new A();
        b.test();  //静态方法输出B，非静态方法输出A！（下面1,2点为解释）
    }
}

1.静态方法是类的方法，而非静态方法是对象的方法，类A和B中的方法是static时，b调用了B类的方法，因为b是用b类定义的；类A和B中的方法不是static时，b调用的是对象的方法，而b是A类new的。

2.静态方法在类加载的时候就已经有了，创建对象之后也没办法改了，引用的话也只是调用类本身的静态方法。

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

（1）方法名必须相同，参数列表必须相同！

（2）修饰符：范围可以扩大。 public > Protected > Default > private。

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

• 快捷键 Alt + Insert : override

多态

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。简单的说:就是用基类的引用指向子类的对象

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

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

public class Application{
    public static void main(String[] args){
        //一个对象的实际类型是确定的
        //new Student();
        
        //可以指向的引用类型就不确定了：父类的引用指向子类
        Student s1 = new Student();
        //Person父类，可以指向子类，但是不能调用子类独有的方法！
        Person s2 = new Student();
        Object s3 = new Student();
        
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！！！
        //Student是子类（run方法（重写），eat方法），Person是父类(run方法)
        s2.run();  //子类重写了父类的方法，执行子类的方法
        s2.eat();  //报错，因为Person里没有eat方法
        ((Student) s2).eat();  //强制转换，无报错
    }
}

• 多态的注意事项：

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

（2）父类和子类，有联系 类型转换异常！ClassCastException！

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

• 无法重写的例子

（1）static 方法，属于类，它不属于实例，无法重写

（2）final 常量

（3）private方法无法重写

instanceof 和类型转换

instanceof

• instanceof 是 Java 的一个二元操作符, 它的作用是测试它左边的对象是否是它右边的类或其任意基类的实例。

public class Application{
    public static void main(String[] args){
        
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        //此处的object实际上为Student类的实例 
        Object object = new Student();
        
        System.out.printIn(object instanceof Student);//true
        System.out.printIn(object instanceof Person);//true
        System.out.printIn(object instanceof Object);//true
        System.out.printIn(object instanceof Teacher);//false
        System.out.printIn(object instanceof String);//false
        
        Person person = new Student();
        
        System.out.printIn(person instanceof Student);//true
        System.out.printIn(person instanceof Person);//true
        System.out.printIn(person instanceof Object);//true
        System.out.printIn(person instanceof Teacher);//false
        System.out.printIn(person instanceof String);//编译报错！左边和右边有联系才可以进行比较！
    }
}

类型转换

//Person父类（run方法）,Student子类（go方法）
public class Application{
    public static void main(String[] args){
        //类型之间的转换   高    低（高转低要使用强制转换，低转高自动）
        Person obj = new Student();
        obj.go();  //编译错误！
        
        //obj将这个对象强制转换为Student类型，我们就可以使用Student类型的方法了！
        
        Student student = (Student) obj;
        obj.go();  //编译成功！
        
        //或者直接((Student) obj).go();
        
    }
}

public class Application{
    public static void main(String[] args){
    
        //子类转为父类，可能丢失自己的本来的一些方法！
        Student student = new Student();
        Person person = student;
    }
}

1.父类引用指向子类对象

2.把子类转换为父类，向上转型（可能会丢失一些方法）

3.把父类转换为子类，向下转型，需要强制转换

4.方便方法的调用，减少重复的代码

Static关键字详解

//数字表示运行的先后顺序
public class Person{
    
    //2 :赋初始值
    {
        System.out.printIn("匿名代码块");
    }
    
    //1 :只执行一次，在第一次执行
    static{
        System.out.printIn("静态代码块");
    }
    
    //3
    public Person(){
        System.out.printIn("构造方法");
    }
        
}

抽象类

//abstract 抽象类 
//类 extends  单继承   （接口可以多继承！）
public abstract class Action{
    //约束
    //抽象方法，只有方法名字，没有方法实现
    public abstract void doSomething();
}

• 抽象类的所有方法，继承了它的子类都必须要实现它的方法

public class A extends Action{
    
}

• 抽象类的特点：

（1）不能new这个抽象类，只能靠子类去实现它：约束！

（2）抽象类中可以写普通的方法

（3）抽象方法必须在抽象类中

（4）抽象的抽象：约束

• 抽象类不能new，但是有构造器

抽象类用来实现封装，多态增强代码的可扩展性。

接口

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有！

接口：只有规范！自己无法写方法~专业的约束！约束和实现分类

接口的本质就是契约！

//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);
}

• 接口都需要有实现类

//接口可以多继承
//类可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService{
    //快捷键alt + enter --> UserServiceImpl
    
    @Override
    public void add(String name){
        
    }
    
    @Override
    public void delete(String name){
        
    }
    ...
    ...
}

• 利用接口可以实现多继承

• 接口的作用：

（1）约束

（2）定义一些方法，让不同的人实现

（3）方法默认为public abstract

（4）常量默认为public static final

（5）接口不能被实例化

（6）implements可以实现多个接口，必须要重写接口中的方法

内部类

内部类就是在一个类的内部在定义一个类。

1. 成员内部类

2. 静态内部类

3. 局部内部类

4. 匿名内部类

public class Outer{
    private int id;
    public void out(){
        System.out.printIn("这是外部类的方法");
    }
    
    public class Inner{
        public void in(){
            System.out.printIn("这是内部类的方法");
        }
        
        //内部类可以获得外部类的私有属性
        //若Inner类改成static静态的，则获取不到id
        public void getID(){
            System.out.printIn(id);
        }
    }
}

public class Appication{
    public static void main(String[] args){
        
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

• 局部内部类（在方法里的类）

public class Outer{
    //局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

• 匿名内部类

public class Test{
    public static void main(String[] args){
        //没有名字初始化类，不用将实例保存到变量中
        //匿名对象的使用
        new Apple().eat();
        
        UserService userService = new UserService(){
            
            @Override
            public void hello(){
                ...
            }
        }
    }
}
class Apple{
    public void eat(){
        System.out.printIn("1");
    }
}

interface UserService{
    void hello();
}

异常机制

异常发生在程序运行期间，它影响了正常的程序执行流程。

• 三种类型的异常（*）

1. 检查性异常：最具代表性的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能简单地忽略。

2. 运行性异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时忽略。

3. 错误：错误不是异常，而是脱离了程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到。

异常体系结构（*）

• Java把异常当做对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。

• 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误ERROR和异常Exception（都是Throwable的子类）

Error和Exception的区别（*）

• Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者执行的操作无关。

• Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

• Exception异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这些异常的发生。

区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程;Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能去处理这些异常。

异常处理机制

抛出异常

捕获异常

异常处理五个关键字：try、catch、finally、throw、throws

public class Test{
    public static void main(String args[]){
        int a = 1;
        int b = 0;
        
        
        try{ //try监控区域
            System.out.printIn(a/b);
        }catch(ArithmeticException e){ //catch 捕获异常
            System.out.printIn("程序出现异常，变量b不能为0");
        }finally{ //无论有没有异常，都会执行finally中的内容
            System.out.printIn("finally");
        }
        
        //finally 可以不要finally  一般是处理IO，资源关闭！
        //假设捕获catch多个异常：从小到大排！
        //快捷键：选中代码，ctrl+alt+T，选择try/catch即可（IDEA）
        
        try{
            ...
        }catch(Exception e){
            e.printStackTrace(); //打印错误的栈信息
        }finally{
            ...
        }
        
    }
    
    //假设这方法中，处理不了这个异常，方法上抛出异常，throws
    public void test(int a, int b) throws ArithmeticException{
        if(b == 0){ //主动的抛出异常 throw,一般在方法中使用
            throw new ArithmeticException();
        }
        System.out.printIn(a/b);
    }
    
     
}

• 用了throws关键字声明，所以调用此方法的时候，方法必须进行异常处理。通过try...catch。

• throw与throws关键字联合使用问题。

（1）throw：抛出异常。

（2）throws：在方法声明处使用，表示此方法不处理异常，而在调用此方法处处理异常。

Exception是必须处理的，而RuntimeException异常是可以不处理的。但是为了保证程序正常运行，最好处理。

如果自定义异常，直接继承异常即可。

自定义异常

//自定义的异常类
public class MyException extends Exception{
    //传递数字>10抛出异常
    private int detail;
    
    //消息的构造器  快捷键alt + insert ，选择Constructor
    public MyException(int a){
        this.detail = a;
    }
    
    //toString:异常的打印信息   
    //快捷键alt + insert 选择toString
    @Override
    public String toString(){
        return "MyException{" + detail + '}';
    }
}

public class Test{
    //可能会存在异常的方法
    
    //第一种方式，catch捕获
    static void test(int a){
        if(a>10){
            throw new MyException(a);  
        } catch(MyException e){
            e.printStackTrace();
        }
    }
    
    //第二种方式throws，抛出，让调用该方法的人去捕获
    static void test(int a) throws MyException{
        
        System.out.printIn("传递的参数为" + a);
        
        if(a>10){
            throw new MyException(a);  //抛出
        }
        System.out.printIn("OK");
    }
    
    //若之前用的第二种方法
    public static void main(String[] args){
        try{
            test(11);
        }catch(MyException e){
            //增加一些处理异常的代码
            System.out.printIn("MyException=>" + e);
        }
    }
    
}

总结

1.处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理

2.在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常

3.尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出

4.尽量添加finally语句块去释放占用的资源