第三周 周总结

面向对象

1、理解对象的属性和方法

对象：用来描述客观事物的一个实体，由一组属性（静态特征）和方法(动态特征)构成

属性：用来描述对象的固有特征，一般是名词。

方法：用来描述对象的动作，这个对象能干嘛，一般是动词；

2、类和对象的关系

类是抽象的，对象是具体的

类是具有相同属性和方法的对象的集合

对象是类的一个实例，是一个具体的实体

3、创建类和对象

4、使用对象

5、方法

构造方法和普通方法的区别：

①构造方法访问修饰符为public，一般方法根据实际情况选择修饰符

②构造方法没有返回值类型， 一般方法无返回值类型为void ，要么有

③构造方法方法名与类同名，一般方法见名思意，遵循驼峰命名

④构造方法的方法体是对象的初始化代码，一般方法是功能的实现

⑤调用方式不一致，一般方法通过对象进行调用，构造方法通过super、this、new

方法重载

同类同名不同参（不同参：不同的参数列表：个数不同、顺序不同、类型不同）

在一个类中有一些方法的功能相同，仅仅是参数列表不一样，此时定义不同的方法名比较麻烦。于是规定，方法名可以一样，但是参数列表必须不一样。所以有了方法的重载

this 关键字的用法  调用对象  、方法 、 构造方法

变量

成员变量与局部变量的区别

1、定义位置不同  

成员变量定义在类中，属于类

局部变量定义在方法中，属于方法

2、作用域不同

成员变量属于类，类中的每一个方法都可以使用

局部变量属于方法，只能在某一个方法中使用

3、初始值不同

成员变量：有默认的初始值，在加载类的时候，就会给成员变量赋值（默认值）

局部变量：没有初始值，必须初始化才可以使用

4、生命周期不同

成员变量：属于类，随着对象的创建而创建，随对象的消失而消失

局部变量：属于方法，随着方法的调用而创建

5、优先级不同

Java三大特性   封装  继承  多态

封装：将某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

封装的原则：1、将属性隐藏起来，使用private关键字修饰属性（被private修饰的内容，只能在本类中使用）

2、对外提供公共的访问方法（赋值、取值），提供getter，setter方法来操作隐藏的属性

封装的实现步骤：①私有化属性 ②创建公共的getter、setter方法；③在setter方法中添加控制语句

封装好处：符合java”高内聚低耦合“思想、隐藏实现的细节，提高安全性  提高了软件的独立性和可重用性

访问权限修饰符

private：只能在同一个类中    public：所有地方    protected   默认修饰符

static 静态修饰符

在内存中只有一个，在加载类的时候创建，被所有方法和对象共享

在其他类中，可以通过类名访问

静态变量在创建对象之前会被加载

实例变量，随着对象的创建被创建

 静态变量不能直接调用非静态的资源

继承

关键字：extends

java只能单继承，即一个类只能有一个直接父类

使用继承：①编写父类，创建公共的属性和方法  ②编写子类使用extends继承父类  ③编写子类中特有的属性和方法

注意：super关键字代表父类，只能出现在子类的方法和构造方法中

          在子类构造方法中使用super调用父类的构造方法，必须位于第一句

          子类不可以直接访问父类中定义为private的属性和方法-private的东西是不被继承的

子类不能继承了父类的哪些东西？

1、private修饰的属性和方法

2、子类和父类不在同一个包下，不能继承默认访问权限的成员

3、不能继承构造方法

存在  is a  情况就可使用继承

XX类（子类）是一个XX（父类）

继承的优点：将子类共有的属性和方法抽取到父类中，减少重复代码，实现代码的复用

重写

当父类的方法不能满足子类的需要时，可以进行重写（必须在继承体系下）

规则：1、方法名必须相同 2、参数列表必须相同 3、返回值类型相同或者是其子类 4、访问权限相等或者不能严于父类

重写存在一模一样的方法，仅仅是方法体不同

重写和重载的区别

重载：同类同名不同参（参数列表不同、类型不同、顺序不同）

重写：在子类和父类中存在，同名同参同返回值同访问修饰符的方法（返回值可以是其子类，访问修饰符不能比父类更严格）简单来说就是一模一样

object 是所有类的父类

Object中常用方法介绍：

类的内容：一般的实体类中都必须包含以下内容：有参构造，无参构造，getset方法，toString() ;

重写equals方法

public class Student
    private int id;
    private String name;
    private int score;

    public boolean equals(Object obj)
        
        if(this==obj){
        return true;    
        }
        if(obj in stance of Student){
                Student s = (Student)obj; 
                if(s.get Id()==this get Id){
                    return true; 
                }
                return false;
                
        }
        return false;

 

3、多态

通过指向父类的引用变量，来调用在不同子类中实现的方法

注意：方法的重写是多态的基础

子类重写父类的某个方法，调用是根据具体的子类实现去调用子类的方法

父类中有一个方法，每一个子类都有不同的实现，可以将该方法定义为抽象方法 被abstract修饰的方法就是抽象方法

抽象方法 没有方法体，只有方法的声明；

如果一个类中存在抽象方法那一定是抽象类，抽象方法不能创建对象

抽象类不能被实例化

抽象方法必须在子类中被重写，除非子类也是抽象类

 如

// 抽象类
public abstract class Pet｛
 //抽象方法
public abstract void toHospital();
｝

4、向上转型

把子类对象直接赋给父类引用叫向上转型，向上转型不用强制转换

Pet p =new Dog();

<父类型> <引用变量名> = new <子类型>();

注意：

1. 此时通过父类引用变量调用的方法是子类重写或继承父类的方法
2. 此时通过父类引用变量无法调用子类特有的方法

5、向下转型 --强制类型转换

向下转型只能使用子类重写的一些方法，和从父类继承的一些方法。如何使用自己独有的一些方法呢？可以使用向下转型。

向下转型需要使用强制类型转换，调用子类特有的方法；

语法：

<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;

如

Dog dog=(Dog)pet;//将pet 转换为Dog类型

dog.method();//执行Dog特有的方法

在进行向下转型的时候，非常容易发生类型转换异常，

ClassCastException --- 类型转换异常

instanceof用于判断一个引用类型所引用的对象是否是一个类的实例

抽象类和普通类的关系

1、有抽象方法的类，一定是抽象类。但抽象类中不一定有抽象方法；

2、一个类继承抽象类，必须重写抽象类中的所有抽象方法，如果没有全部重写，那么子类必须声明为抽象类

3、抽象类中可以有构造方法，创建子类的实例时调用

抽象类和普通类的区别

1、语法不同，抽象类是被abstract修饰的类，普通类一定不能被abstract修饰；

2、抽象类中可以有抽象方法，普通类中一定不能有抽象方法；

3、抽象类不能被实例化，普通类可以实例化调用；--创建对象

4、抽象类被继承时，子类必须重写所有父类的抽象方法，或者将子类声明为抽象类；普通类继承普通类时，没有任何限制。

接口

1、interface，是抽象方法的集合（接口中所有的方法都是抽象方法）

为了弥补Java中只可以单继承的缺陷，把这个特殊的类叫做接口，使用interface接口

接口并不是类，编写接口的方式和相似，但是他们属于不同的概念

2、接口的声明

public interface MyInterface {
	public abstract void eat(); // 接口中的所有方法都是抽象方法；
	void run(); // 可以省略前面的修饰
}

3、接口的特点

1、接口不能用于实例化对象。

2、接口没有构造方法。

3、接口中所有的方法必须是抽象方法。默认为：public abstract

4、接口不能包含成员变量，除了 public static final 常量。

5、接口不是被类继承了，而是要被类实现。实现使用关键字：implements

6、接口支持多实现。

7、一个类可以继承一个类的同时实现多个接口。

3：使用接口

使用接口的步骤：

1、创建接口，声明方法

2、创建类，实现接口，实现接口中的方法

3、使用实现后的方法执行具体的操作

4：接口与抽象类的区别  

1、抽象类使用关键字abstract class修饰，接口使用关键字interface；

2、抽象类使用关键字extends实现继承，接口使用implements来实现

3、抽象类中可以包含抽象方法和普通方法，接口中只能有抽象方法（1.7）；

4、抽象类可以有构造方法，接口中不能有构造方法；

5、抽象类可以有成员变量，接口中只能有常量；

6、抽象类只能单继承，接口可以多继承；

7、抽象类里面的方法可以是public,protect,private，接口的方法只能是public；

异常

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常

常见的异常有：先记5个

算术异常：ArithmeticExecption

空指针异常：NullPointerException

数组下标越界异常：ArrayIndexOutOfBoundsException

类型转换异常：ClassCastException

数组负下标异常：NegativeArrayException

字符串转换为数字异常：NumberFormatException

输入类型不匹配：inputMisMatchException

捕获异常： try , catch , finally

try-catch-finally 执行顺序：

A）try中没有捕获异常时，try代码块中的语句依次被执行，跳过catch。如果存在finally 则先执行finally再执行后续代码。否则执行后续代码。

B）try中捕获到异常时，如果存在匹配的catch，则跳到该catch代码块执行处理。如果存在finally则先执行finally代码块，然后执行后续代码；否则直接执行后续代码。

注意：try 代码块中出现异常之后的代码不会被执行

C）try捕获到异常时，如果没有匹配的catch，则该异常交给JVM处理。如果存在finally，则其中的代码仍然被执行，但是finally之后的代码不会被执行

如果try代码块或者catch代码块中存在return的时候，finally代码块将在方法返回前被执行。先执行finally，最后执行return

抛出异常：throw, throws   

自定义异常

自定义异常的具体步骤：

1：定义一个类继承Exception或者其子类；

class <自定义异常名> extends <Exception>

2：编写构造方法（无参和有参）；

3：在需要的地方调用异常类（使用throw 抛出实例化后的异常）- 在方法的声明中需要声明

异常使用原则

不要将所有的代码都放在try中，try中放可能发生异常的代码

在catch中指定具体的异常类型

能解决的使用捕获，不能解决的使用抛出