java第五周学习

Posted 2020-08-27

在Java中类与类之间的关系

1.聚合关系 : 两个类的关联程度较低，可以单独存在。

2.组合关系 : 两个的关联程度比较高。

    Java中如何来表现这个关系。

        一类A作为属性存在类B中。

3.依赖关系: 两个类的关联程度比较高。

     一个类中定义一个方法，将另外一个类作为方法的参数。

  

4.关联关系: 它的写法和整体和部分的关系的的写法是样的，表达的含义比一样。

5.继承关系

面向对象的三大特征之一: 继承

想判断两个类之间是否存在继承关系？

通过判断两个类之间是否有所属关系。 is a 语句来判断

Java中如何来描述两个类的继承关系:

通过extends关键之来描述继承关系。

格式:

       class A extends B{          }

类A叫类B的子类。

       类B称为类A的父类(超类,基类)

继承的作用: 减少重复代码(优化代码的方式)

继承的使用注意点:

      1.不要为了节省代码乱继承。 要想使用继承必须存在有继承关系。

      2.java中的继承属于单继承。 一个子类只允许有一个父类。允许多重继承。

      3.父类中一般是子类的公有的成员(属性和行为)。子类是允许有自己独用的行为和属性。

      4.父类类私有成员是不能继承的。

      5.构造方法也是不能继承的。

      6.子类创建对象的时候会默认调用父类的无参构造方法。

      7.父类中最好存在有无参的构造方法。

      8. 如果子类中和父类中同名的成员时，默认是优先使用子类。

      9. 如果子类构造方法中指定了调用父类的构造方法，那么就不会在调用父类中的无参构造方法。

super关键字

super: 用来引用父类的空间

super关键字的应用:

      1.在子类中用来直接调用父类中成员变量。

      2.在子类的构造方法中调用父类的构造方法。

super调用构造方法的使用注意点:

1. 如果super用来调用父类的构造方法，那么super语句必须是子类的构造方法中的第一个语句。

super关键字和this关键字的区别:

    1关键字的含义比较

        1.this关键字所属的方法的调用者对象。

        2.super表示父类空间的引用

    2使用前提来比较

        1.this关键字不需要继承也可以使用

        2.super关键字必须要有继承

     3调用构造方法比较

        1.this关键字是调用当前类的构造方法

        2.super代用父类的构造方法。

 

方法的重写

作用:扩展父类中的方法。

使用场景:父类中方法满足不了子类

方法重写的注意点:

 1.子类中的方法要和父类中的方法同名

 2.子类中的参数列表要和父类的一样

 3.子类的权限修饰符要大于等于父类的权限修饰符。

 4.返回值类型和父类一样，或者是父类的子类。

final修饰符

意思:最终的,不可更改的.

作用:1,可以用来修饰变量

     2.可以用来修饰方法

     3.可以用来修饰类

使用注意点:

                  1.一个变量如果被final修饰了必须要初始化

         2.如果一个基本数据类型变量被final，变量就不能修改了

         3.如果用final修饰一个引用数据类型变量，那么这个变量就不能再引用其他对象

         4.如果final修饰方法，方法就不允许重写。

         5.如果final修饰一个类，那么这个类就不允许被继承。

 

抽象类

抽象方法的使用场景: 有一个事物存在某种行为，但是没有具体的实现。可以通过抽象类来实现

定义抽象方法: abstract关键字

抽象方法定义格式: abstract 方法名();

抽象类的定义格式: abstract class 类名{}

 

abstract的使用注意事项:

       1.abstract修饰的方法是一个抽象的方法，方法不允许有主体。

       2.一个类中如果有抽象方法，那么这个类一定是一个抽象类。

       3.一个类如果继承抽象类，那么你就必须要重写抽象类中的所有的抽象方法。

       4.一个抽象类中允许抽象方法和非抽象方法共存。

       5.抽象类不能创建对象。

       6.抽象类中是可以定义构造方法。

       7.抽象类中是可以没有抽象方法。

abstract修饰方法不能和一下关键字连用:  

                abstract不能和private一起修饰方法。

             abstract不能和static一起修饰方法。

             abstract不能和final一起来修饰方法。

抽象类和普通类的区别:

   1.抽象类有abstract关键字修饰，普通类没有

   2.抽象类有抽象方法，普通了没有。

   3.抽象类不能创建对象，普通类可以创建对象。

 

接口

使用interface 关键字来表示接口。

定义接口的格式:

    

     interface 接口名 {接口的内容}

 

实现接口:

    implements : 表示实现

    class B implements 接口名{

 }

接口的使用注意点:

      1.接口中定义的方法是没有主体的。接口中的方法默认都是抽象方法。

      2.接口中定义的变量默认都是常量。修饰方式:public static final。

      3.接口不能定义构造方法

      4.接口需要用其他的类来实现。

      5.如果一个普通类实现接口，那么就必须要实现接口中的所有方法。

      6.如果是一个抽象类实现接口，类就不一定需要实现接口中的方法。

      7.接口是支持都多实现的。一个类可以实现多个接口。

      8.接口不能创建对象。

     

Java 面向对象的第三大特征: 多态

多态的变现形式:1.父类的类型指向子类的对象

                               2.接口类型指向接口类型的实现对象

        

1.父类的类型指向子类的对象:

示例:

Animal a = new Dog();

 

多态的使用注意事项:

       1.要想有多态必须要有继承。

       2.多态中要有方法的重写

       3.子类和父类中有同名的非静态方法，默认是调用子类中的方法。

       4.子类和父类中有同名的变量，默认是调用父类中的。

       5.子类和父类中有同名的静态方法。默认调用父类中的方法。

 

总结:子类和父类中存在同名成员，默认是调用父类中的，非静态方法除外。

 

多态的应用:

    1.在方法中用于形参进行传递。可以增强代码的可扩展性

2.在方法中用于返回值，可以返回多种类型的对象

 (这个时候需要用到数据类型的转换,数据转换之前需要判断某个对象是否属于某个类型)

在引用数据类型中: 子类向父类转换叫自动类型转换。

   示例  Aniaml a = new Dog();

   在引用数据类型中: 父类向子类进行转换叫强制类型转换。

  示例: a instanceof Mouse

       Mouse m = (Mouse)a

 

 

2.接口类型的变量指向接口实现类的对象

示例:

接口 a = new 实现类();

a 就可以实现接口里面的方法

 

内部类

定义: 在一个类的内部存在有另外一个类。

内部类的class文件的命名: 外部类$内部类

内部类的使用场景:

         一个类A中要使用到另外一个类B，类B中又要使用到类A，这个时候就需要使用到内部类。

在一个类内部类分为两种:

 1 成员内部类

 2.局部内部类

 

成员内部类

         定义在内里面方法外面的类叫成员内部类。

访问内部类的方式:

             方式一:

                在外部类中提供一个方法来初始化内部内对象，在方法中对对象做操作。

 

             方式二:  只有成员内部类可以使用。

                在其他类中间接的创建内部类对象直接使用。

                格式: 外部类.内部类  对象 = new 外部类().new 内部类();

内部类的使用注意点:

           1.外部类中定义的成员可以在内部类中直接访问到

           2.如果内部类中的成员和外部类的成员同名，就近原则，调用内部类中的。

           3..如果内部类中的成员和外部类的成员同名,可以通过 外部类名.this.属性名 来获取到外部类的属性。

           4.如果static修饰内部类 ，内部类中访问的成员需要使静态的。

 

局部内部类

         定义在方法中的类。

访问局部内部类的方式:在外部类中提供一个方法来初始化内部内对象，在方法中对对象做操作

局部内部类的使用注意点:

1. 内部类中想访问外部类中 的局部变量，这个局部变量必须用final来修饰

 

匿名内部类

匿名内部类:就是没有名字的内部类。

 

匿名内部类的作用: 简化代码

 

匿名的内部类需要通过 继承或者接口来实现

 

异常

程序和代码的不正常情况，叫异常

 

异常类:用一个类来描述所有的异常情况叫异常类

 

异常体系:所有的异常类组合起来称为异常体系

 

 Object : 所以异常和错误的超类

 

 Throwable: 所有异常的超类

 

Error ：错误类

 

Execption：异常类

 

继承图:

Throwable:类中最常见的三种方法

1         toString() 返回此 throwable 的简短描述 :描述的是类的完整类名+传入的异常信息。

2         getMessage()  获取传入的异常信息

 

3         printStackTrace()打印异常的栈信息

 

 

 

Error ：错误 : 指的是jvm或者硬件的原因导致的错误 .无需人工处理

 

Execption：异常 : 指的是jvm虚拟机产生的异常

 

         判断打印的是异常还是信息:

如果打印信息的后面是以error结尾的 ，打印出来的就死活一个错误信息。

               如果打印的信息的后面是以Execption结尾的，打印出来的是异常信息。

 

处理异常的方式有两种:

         1.捕获处理异常:

            

             捕获处理异常的格式:

 

               try{//可能出现异常的代码}catch(接收异常的变量){

              

                 //处理异常的操作

               }

 

捕获异常的使用注意点:

             1.如果try中的代码出现了异常，出现异常之后的代码就不会执行了。

             2.一个try后面可以处理多个异常。

             3.捕获异常的时候可以直接捕获一个最大的异常Execption

             4.捕获的异常需要按照由小到大的顺序排列。