第五周总结

来源：互联网发布：淘宝差价链接怎么做编辑：程序博客网时间：2024/05/22 18:18

重点：
1.继承
2.抽象
3接口
4.多态
5.异常

1. 面向对象的三大特征:

   1.封装 ：      1.private私有，用来修饰属性。      2. private为私有的属性提供两个公开的访问方法: set方法和get方法         set方法和get方法的命名方法:         set属性名。 set方法有一个参数     给属性赋值         get属性名。 get方法有一个返回值  获取属性的值  2.继承  3.多态

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

1 判断两个类之间是否存在继承关系？
3. 是通过判断两个类之间是否有所属关系。
什么时候使用继承呢？
当类与类之间存在着所属关系时，才具备了继承的前提。
a 是 b 中的一种。a 继承b。狼是犬科中的一种。英文书中，所属关系：” is a
” 注意：不要仅仅为了获取其他类中的已有成员进行继承。所以判断所属关系，可以简单看，如果继承后，被继承的类中的功能，都可以被该子类所具备，那么继承成立。如果不是，不可以继承。
2）Java中如何来描述两个类的继承关系:
通过extends关键字来描述继承关系。
格式:
class A extends class B{ // 表示类A继承了类B
类A的一个实现。
}
类A叫类B的子类。
3）继承的作用:
1：提高了代码的复用性。
2：让类与类之间产生了关系，提供了另一个特征多态的前提。
4）继承的使用注意点:
1.不要为了节省代码乱继承。要想使用继承必须存在有继承关系。
2.java中的继承属于单继承。一个子类只允许有一个父类。允许多重继承。
3.父类中一般是子类的公有的成员(属性和行为)。子类是允许有自己独有的行为和属性。
4.父类私有成员是不能继承的。
5.构造方法也是不能继承的。
6.子类创建对象的时候会默认调用父类的无参构造方法。
7.父类中最好存在有无参的构造方法。
1. 3.方法的重写的作用:
扩展父类中的方法。
2）使用场景:
3）方法重写的条件:
1.子类中的方法要和父类中的方法同名。
2.子类中的参数列表要和父类的一样。
3.子类的权限修饰符要大于等于父类的权限修饰符。
4.返回值类型和父类一样，或者是父类的子类。
5.子类的抛出的异常要小于等于父类的异常。如果子类和父类中有同名的成员时，默认是优先使用子类。
4）疑问:既然不能继承父类的构造方法，为什么在创建对象的时候，还要调用父类的无参构造。
目的:将父类中的属性初始化。
如果子类构造方法中指定了调用父类的构造方法，那么就不会在调用父类中的无参构造方法。

4. super关键字

2）super关键字的作用:
1.在子类中用来直接调用父类中成员变量和成员方法。
3）super调用构造方法的使用注意点:
1.如果super用来调用父类的构造方法，那么super语句必须是子类的构造方法中的第一个语句。
4）super关键字主要存在于子类方法中，用于指向子类对象中父类对象。

super关键字和this关键字的区别:
1.关键字的含义:
1.this关键字所属的方法的调用者对象。
2.super表示父类空间的引用
2.使用前提来看:
1.this关键字不需要继承也可以使用
2.super关键字必须要有继承
3.调用构造方法
1.this关键字是调用当前类的构造方法
2.super调用父类的构造方法。

在继承中this和super访问成员。
this访问成员: 先在本类中查找，如果找到了就使用本类中的，如果没有找到，接着去父类中查找，如果找到了就使用父类中的，如果没有就到父类的父类中查找，直到找到为止。如果最终没有找到就报错。
super访问成员:如果加上了一个super关键字：直接先到父类中查找，如果有就直接使用，如果没有找到就继续到父类父类中找，如果找到了就直接使用，最后还是没有找到就报错。
注意：
1.子类中所有的构造函数都会默认访问父类中的无参数的构造函数，因为每一个子类构造内第一行都有默认的语句 super();
2.如果父类中没有无参数的构造函数，那么子类的构造函数内，必须通过 super 语句指定要访问的父类中的构造函数。
3.this super只能在有对象的前提下使用，不能在静态上下文使用。
4.构造函数间的调用只能放在第一行，只能调用一次。
方法重载:
1.类中方法名一样
2.参数列表不一样
Super：代表是子类所属的父类中的内存空间引用。

final(最终的，修饰符) 继承的一个弊端：打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。这时如何解决问题呢？介绍一个关键字，final:最终。
1：这个关键字是一个修饰符，可以修饰类，方法，变量。
2：被 final 修饰的类是一个最终类，不可以被继承。
3：被 final 修饰的方法是一个最终方法，不可以被覆盖。
4 : 被final 修饰的变量是一个常量，只能赋值一次。
2）常量名称定义规范，所有字母都大写，如果由多个单词组成，中间用 _连接。
3）final使用注意点:
1.一个变量如果被final修饰了必须要初始化.
2.如果一个基本数据类型变量被final修饰，变量就不能修改了。
3.如果用final修饰一个引用数据类型变量，那么这个变量就不能再引用其他对象。
4.如果final修饰方法，方法就不能重写。
5.如果final修饰一个类，那么这个类就不能被继承。
常量的定义格式: public static final 常量名 = 值;

抽象类:

1：当描述一个类的时候，如果不能确定功能方法如何定义，那么该类就可以定义为抽象类，功能方法应该描述为抽象方法。用abstract关键字修饰的类叫抽象类。
2：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由 abstract 关键字修饰。
抽象类的定义格式:
abstract class 类名{} Java中定义抽象方法:
定义格式:
abstract 方法名();

抽象类的使用场景：有一个事物存在某种行为，但是没有具体的实现。可以通过抽象类来实现，把这种不确定的行为叫抽象的方法。这个时候就需要使用抽象类。
abstract的使用注意事项:
1.abstract修饰的方法是一个抽象的方法，方法不允许有主体。
2.一个类中如果有抽象方法，那么这个类一定是一个抽象类。
3.一个类如果继承抽象类，那么你就必须要重写抽象类中的所有的抽象方法。
4.一个抽象类中允许抽象方法和非抽象方法共存。
5.抽象类不能创建对象。
6.抽象类中是可以定义构造方法。给子类初始化父类中的属性。
7.抽象类中是可以没有抽象方法。
2）abstract不能和以下关键字连用: 针对的是抽象方法。
abstract不能和private一起修饰方法。
abstract不能和static一起修饰方法。
abstract不能和final一起来修饰方法。
4）抽象类和普通类的区别:
1.抽象类有abstract关键字修饰，普通类没有。
2.抽象类有抽象方法，普通类没有。
3.抽象类不能创建对象，普通类可以创建对象。

接口

1：是用关键字 interface 定义的。
2：接口中包含的成员，最常见的有全局常量、抽象方法。
成员变量：public static final 。
成员方法：public abstract 。
interface Inter{
public static final int x = 3;
public abstract
1）java中如何来实现功能的拓展:
可以通过接口来实现。
2）java中如何表示一个接口: 使用interface 关键字来表示接口。
定义接口的格式:
interface 接口名 {
接口的内容
}
3）接口的使用注意点:
1.接口中定义的方法是没有主体的。接口中的方法默认都是抽象方法。
2.接口中定义的属性都是常量。默认是被:public static final修饰。
3.接口不能定义构造方法。
4.接口需要用其他的类来实现。
5.如果一个普通类实现接口，那么就必须要实现接口中的所有方法。
6.如果是一个抽象类实现接口，类就不一定需要实现接口中的方法。
7.接口是支持多实现的。一个类可以实现多个接口。
8.接口不能创建对象。
4）如何实现接口: implements : 表示实现 class B implements 接口名{ }
类实现接口注意点:
1.普通类实现接口，需要实现接口中的所有方法(指的是当前接口中的方法，以及父接口中的方法)。
2.抽象类不一定要实现接口中的方法。
3.一个类可以实现多个接口。
7）接口和接口之间的关系: 继承关系
接口的继承是支持多继承。继承用 extends ；实现用 implements ；
8）接口的作用:
1.拓展类的功能。
2.定义约束条件。
3.代码的解耦。
1.抽象类与接口：抽象类和接口的共性：都是不断向上抽取的结果。
2.抽象类和接口的区别：
2：抽象类中可以定义非抽象方法，子类可以直接继承使用。接口中都是抽象方法，需要子类去实现。
3：抽象类使用的是 is a 关系。
4：抽象类的成员修饰符可以自定义。接口中的成员修饰符是固定的。全都是 public 的。

多态

1）多态：一个事物的多种表现形式。父类的类型变量指向子类对象，或者接口类型指向接口的实现类对象现实生活中的多态：
生活中的水：液态，气态，固态。多态的表现形式：狗是动物 Animal a = new Dog();
2）多态的使用注意点：
1.多态必须要有继承。
2.多态要有方法的重写。
3.子类和父类中，如果存在同名的成员，默认是调用父类中的方法，非静态方法除外。
3）多态的使用：编译时看左边，运行时看右边。
编译时看左边：Animal a = new Dog();编译的时候会先检测左边这个类型中是否有指定的属性和方法，如果没有就会报错。
运行时看右边：Animal a = new Dog();具体的方法的实现是看右边的对象（在非静态方法重写的情况下）。
4）多态的应用：
1.在方法中用于形参进行传递，可以增强代码的可扩展性。
2.在方法中用于返回值，可以返回多种类型的对象。
多态的情况下访问子类所特有的成员需要用到强制类型转换。
1.子类向父类转换叫自动类型转换
类型的转换:
1.自动类型转换小的类型向大的类型转换叫自动类型转换。
2.强制类型转换大的类型向小的类型转换叫强制类型转换。
2.instanceof关键字
intanceof必须继承才可以使用。
接口下的多态：接口类型的变量指向接口实现类的对象。
多态格式：
对象名 instanceof 类名：返回一个boolean类型的结果。
3.内部类
—– 内部类：在一个类的内部存在另外一个类。
好处：可以直观的看出内部类属于谁。
2）内部类的使用注意点：
1.外部类中定义的成员可以在内部类中直接访问。
2.如果内部类中的成员和外部类的成员同名，使用就近原则。
3.如果内部类中的成员和外部类的成员同名,可以通过外部类名.this.属性名来获取到外部类的属性。
4.如果static修饰内部类，内部类中访问的成员需要使用静态的。内部类编译后的文件名为：“外部类名$内部类名.java”；
3）内部类的使用场景：一个类A中要使用到另外一个类B，类B中又要使用到类A，这个时候就需要使用到内部类。
4）在一个类中，内部类分为两种：
1.成员内部类：定义在类里方法外面的叫成员内部类。
访问内部类的方式：
方式一：在外部类中提供一个方法来初始化内部对象，在方法中对对象做操作。
方式二：只有成员内部类可以使用。
在其他类中，直接创建内部类对象
格式：
外部类.内部类对象 = new 外部类(). 内部类();
局部内部类的访问方式：在局部内部类里创建对象，用方法去访问。
1）局部内部类的使用注意点：
1.内部类中想访问外部类中的局部变量，这个局部变量必须用final修饰。
4.匿名内部类：没有名字的内部类。
匿名内部类的作用: 简化代码.
匿名内部类的使用场景：匿名内部类也可以作为方法的实参进行传递。
匿名的内部类需要通过继承或者接口来实现。
new 父类或者接口(){
};
注意细节：
1.使用匿名内部类时，如果需要调用匿名内部类的两个方法或者两个方法以上。可以使用变量指向该对象。

异常:

java程序的不正常情况，叫异常。在代码中也会出现不正常的情况，这种不正常情况叫异常。
1) Java是一个面向对象的编程语言，所有的事物都可以用一个类来描述，异常在Java中也可以用一个类来描述，我们就将这种类叫异常类。Java中的异常类有很多，将很多的异常类称为异常体系。
2) Throwable : java中所有的异常的超类.
——Error ：错误
——Execption：异常 Throwable 在java.lang包中. Throwable:
toString(); 返回此 throwable 的简短描述 :描述的是类的完整类名+传入的异常信息。
getMessage(); 获取我传入的异常信息。
java中会默认导入lang包。
Throwable : java中所有的异常或错误的超类.
——Error ：错误 : 指的是jvm或者硬件的原因导致的错误，一般情况下不需要人为的来处理
3）如何判断打印的是异常还是错误:
如果打印信息的后面是以error结尾的，打印出来的就是一个错误信息。
如果打印的信息的后面是以Execption结尾的，打印出来就是异常信息。 4） Java中如何来处理异常:
jvm虚拟机默认管理的内存是64m。
处理异常的方式有两种:
2.抛出处理异常:
1.捕获处理异常:
捕获处理异常的格式:
try{
//可能出现异常的代码
}catch(接收异常的变量){
//处理异常的操作
}
5）捕获异常的使用注意点:
1.如果try中的代码出现了异常，出现异常之后的代码就不会执行了。
2.一个try后面可以处理多个异常。
3.捕获异常的时候可以直接捕获一个最大的异常Execption。
4.捕获的异常需要按照由小到大的顺序排列。
5.如果tiy中的代码出现异常，cry-catch后面的代码会正常执行。

0 0