java基础之面向对象

java基础之面向对象

1、初始面向对象

​ 1、面向对象编程：OOP

​ 2、实质：以类的方式组织代码，以对象的组织（封装）数据

​ 3、特性：封装、继承、多态

​ 4、对象是一个具体的实例

​ 5、对象通过引用来操作

2、构造器

1、构造器即构造方法，和类名相同，没有返回值，是用来实例化初始值。

2、默认有一个无参构造器

3、使用new关键字，实际是在调用构造器

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

5、生成构造器的快捷方法：alt+insert

6、this代表当前类

3、对象的创建和使用

​ 1、必须使用new关键字创造对象

​ 2、使用对象去引用类的方法和属性

4、封装

1、程序要追求高内聚，低耦合，即类的内部数据操作细节自己完成，不需要外界的干涉

​ 低耦合：仅暴露少量的方法给外部使用

2、封装：应该机制直接访问一个对象中数据的实际表示，而通过接口来访问，这叫信息隐藏。

3、属性私有，get/set

4、意义：提高程序的安全性，保护数据，统一接口、提高了可维修性

5、继承

1、关键字extends，子类会继承父类的方法和属性。shy

2、Java只有单继承，没有多继承

3、 ctrl+H：结构树

4、所有的类都默认继承OBject类

6、super

1 、使用super.属性，调用父类的属性

2、super.方法名（）:调用父类的方法

3、super只能出现在子类的方法或者构造方法中

4、super和this不能同时调用构造方法

5、父类没有无参构造，子类也不能写

7、重写

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

​ 1）方法名必须相同

​ 2）参数列表必须相同

​ 3）修饰符：范围可以扩大但不能缩小

​ 4）抛出的异常：范围，可以被缩小，但不能扩大

​ 即子类的方法和父类必须一致，方法体不同。

2、静态和非静态的区别

​ 例子 1,在定义方法为static类型的情况下，override：重写

父类A
package com.yyr.methodtext;

public class A {
 public static void test(){
     System.out.println("A=>test");
 }
}

子类B：
package com.yyr.methodtext;

public class B extends A{
   public static void test(){
        System.out.println("B=>test");
    }
}

C类测试类
package com.yyr.methodtext;

public class C {
    public static void main(String[] args) {

        B b=new B();
        b.test();   //B子类


       //父类的引用指向了子类
        A a =new B();//子类重写了父类的方法
        a.test();    //A父类

    }
}

结果：

​ 例子2,在定义方法不是static类型的情况下

父类A：
package com.yyr.methodtext;

public class A {
    public void test(){
        System.out.println("A=>test");
    }
}

子类B：
package com.yyr.methodtext;

public class B extends A{
    public void test(){
        System.out.println("B=>test");
    }
}

C类测试类：
package com.yyr.methodtext;

public class C {
    public static void main(String[] args) {

        B b=new B();
        b.test();   //B子类


       //父类的引用指向了子类
        A a =new B();//子类重写了父类的方法
        a.test();    //A父类

    }
}

结果：

3、结论：静态的重写和非静态的重写的差别很大

​ 静态：方法的调用只和作步，定义的数据类型有关

​ 非静态方法：重写

8、多态

1、多态：即同意方法可以根据发送对象不同而采用不同的行为

2、多态是方法的多态，属性没有多态

3、父类和子类有关系

4、存在条件：继承关系，方法需要重写。父类的引用指向子类对象。father f1=new son（）

ps（ 1、数据类型能够强制转换：（类名）对象名）

9、instanceof和类型转换

1、instanceof （类型转换），引用类型，判断是否存在父子关系

2、完全没关系的编译的时候就会报错

3、数据类型能够强制转换：（类名）对象名

4、子类转换为父类可能会丢失一些方法

5、父类转换为子类：强制转换

10、抽象类

1、abstract修饰符可以用来修饰方法也可以修饰类

2、抽象类中可以没有抽象方法，但是又抽象方法的类一定要声明为抽象类

3、抽象类不能用new关键性创建对象，同时用来让子类继承的

4、抽象方法：只有方法的声明，没有方法的实现，是用来让子类实现的，

5、子类继承抽象类，就必须实现抽象类的抽象方法，否则也要定义为抽象类

11、接口

1、类只有单继承，但是接口可以实现多继承

2、只有规范，无法写方法，约束和实现分离

3、接口就是规范，定义的是一组规则。

4、声明接口的关键字：interface

5、类可以实现接口，关键字：implements 可以实现多个接口，必须实现接口中的方法

6、接口定义的常量格式：public static final

7、接口不能实例化：没有构造方法

12、异常的概念

1、异常类分为两类：error错误和异常Exception

2、Error类对象由java虚拟机生成并抛出。

3、RuntimeEcveption:运行时异常

​ ArrayIndexOutOfBoundsException:数组下标越界

​ NullPointerException:空指针异常

​ ArithmeticException:算术异常

​ MIssingResourceException:丢失资源

​ ClassNotFoundException:找不到类

13、异常处理机制

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

2、抛出异常，捕获异常

3、try：监控区域。catch:捕获异常。

4、try和cath两个代码块。

5、代码如下：

package com.yyr.tryText;

public class tryText01 {
    public static void main(String[] args) {
        int a=10;
        int b=0;

        try{//try监控区域是否出现异常
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch捕获异常，括号内是想捕获的异常类型
            System.out.println("除数不能为0");
        }finally {//善后工作
            System.out.println("finaly");
        }
    }
}


结果：
除数不能为0
finaly

6、throwable：最大的异常

7、相应捕获多个异常，要从小到大

8、control+alt+t:选择对应的代码块，可以被包裹起来

9、监控到异常，还可以抛出异常。throw，throws

10、方法中处理不了这个异常，就在方法上抛出异常

package com.yyr.tryText;

public class tryText02 {
    public static void main(String[] args) {
        new tryText02().test(1,0);

    }//假设这方法中，处理不了这个异常，就在方法上抛出
    public void  test(int a, int b) throws ArithmeticException{
     if (b==0){
         throw  new ArithmeticException();//主动的抛出异常，一般在方法中使用
     }
    }
}
结果：

14、自定义异常

​ 1、步骤：（继承Exception类）

​ 1）创建自定义异常类

​ 2）在方法中通过throw关键字抛出异常对象

​ 3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理

​ 4）在出现异常方法的调用者中捕获并处理异常

2、alt+enter

3、代码

异常类
package com.yyr.tryText;

public class MyException extends Exception{
    //传递数字>10就抛出信息
    private int detail;
    //public定义的主方法好像不能定义私有变量
    public  MyException(int a){
       this.detail=a;
    }
    public String toString(){//异常的打印信息
        return "MyException{"+
                "detail"+detail+"}";
    }
}

测试类：
package com.yyr.tryText;

public class tryText03 {
    //可能或存在异常的方法
    static void test(int a ) throws MyException {
        System.out.println("传递的参数为："+a);
        if(a>10){
            throw new MyException(a);//在这儿a会标红，选择捕获还是抛出
            //用alt+enter
            //这儿抛出异常
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            test(1);
        }catch (MyException e){
            e.printStackTrace();
        }
    }
}

更改测试类参数后
package com.yyr.tryText;

public class tryText03 {
    //可能或存在异常的方法
    static void test(int a ) throws MyException {
        System.out.println("传递的参数为："+a);
        if(a>10){
            throw new MyException(a);//在这儿a会标红，选择捕获还是抛出
            //用alt+enter
            //这儿抛出异常
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            test(11);
        }catch (MyException e){
            e.printStackTrace();
        }
    }
}

结果：