java面向对象---2

一、 面向对象–继承性

1、继承性格式

class A  extends B{}
//A:子类、派生类
//B:父类、基类

2、继承性说名明
①、一旦子类A继承父类B后，子类A就获取了父类B中声明的所有属性和方法
父类中声明为private的属性和方法，子类继承父类后，仍然获取了父类私有结构，但是因为封装性，子类不能直接调用父类的结构。
②、子类继承父类后，还可以声明自己特有的属性和方法：功能实现拓展
3、继承性好处
①、减少代码量，提高代码复用性
②、便于功能拓展
③、为之后多态的使用，提供前提
4、Java中继承性的规定
①一个类可以被对个子类继承
②一个子类只能有一个父类
③子父类是相对的
④子类直接继承的父类。称为:直接父类。间接继承的父类称为:间接父类
⑤子类继承父类后，就获取了直接父类和所有间接父类中声明的属性和方法
5、
①如果我们没有声明一个类的父类，则此类继承与java.lang.Object类
②所有java类都直接或间接的继承与java.lang.Object类

二、 面向对象–方法重写

1、重写

子类继承父类后，可以对父类中同名同参数的方法，进行覆盖操作

2、应用

重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名参数的方法时，实际上执行的是子类重写父类的方法

public class Person {
    private int age;
    private String name;

    //构造方法
    public void Person(){

    }
    public void say(){
        System.out.println("说话");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}

public class Student extends Person{
    private String we;//体重
    //构造方法
    public void Student(){

    }
    public void sty(){
        System.out.println("学习");
    }
    //方法的重写
    public void eat(){
        System.out.println("吃好吃的");
    }
}

3、重写的规定

①子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
②子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
特殊情况：子类不能重写父类中声明为private权限的方法
③返回值类型
(1)父类被重写的方法的返回值类型是void，子类重写的方法的返回值类型也必须是void。
(2)父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类。
(3)父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型也必须是基本数据类型。
④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

4、super关键字

(1)、我们可以在子类的方法或构造器中。通过使用“super.属性”或“super.方法”的方式，显示的调用父类中声明的属性或方法。但是通常情况下，我们习惯省略“super.”
(2)、特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，必须显示的使用“super.属性”的方式，表明调用的是父类中声明的属性
(3)、特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类被重写的方法时，必须显示使用“super.方法”的方式，表明调用的是父类中重写的方法。
(4)、super调用构造器
①我们可以在子类的构造器中显示的使用“super(形参列表)”的方式，调用父类中声明的指定构造器
②“super(形参列表)”的使用必须声明在子类构造器的首行
③我们在类的构造器中，针对“this(形参列表)”或“super(形参列表)”只能二选一，不能同时出现
④在构造器的首行，没有显示的声明“this(形参列表)”或“super(形参列表)”，则默认调用的是父类中空参构造器
⑤在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类的构造器。

三、 面向对象–多态性

1、对象的多态性：父类的引用指向子类的对象

//对象的多态性
Person p1 = new Student();

2、多态的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，实际上执行的是子类重写父类的方法
总结：编译看左边，运行看右边
3、多态性的使用前提：①类的继承关系②方法的重写
4、对象的多态性只适用于方法，不适用于属性。(编译和运行都看左边)

1、向下转型

有了对象的多态性以后，内存中实际是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时只能调用父类中声明的属性和方法，子类特有的属性和方法不能调用。
如何调用子类的属性和方法？
向下转型：使用强制类型转换符

//对象的多态性
Person p1 = new Student();

//向下转型
Student m1 = (Student)p1;
//使用强转是可能出现转换失败的异常

2、instanceof关键字

(1)、使用：

a instanceof A
//判断对象a是否为A类的实例，如果是返回true，不是返回false
//一般在向下转型之前使用instanceof判断

//如果a instanceof  A返回true，则a instanceof B也返回true，
//其中类B是类A的父类

四、 Object类

1、==和equals()方法

2、toString()的使用
①当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
②Object类中toString()的定义…
③像String、Data、File、包装类等都重写了Object类中toString()方法，使得在调用toString()方法时显示实体内容。

五、 包装类

1、Java提供了8种数据类型对应的包装类，使基本数据类型的变量具有类的特征

2、使用
①基本数据类型转换成包装类：调用包装类的构造器即可

int num1 = 10;
//基本数据类型转换成包装类
Integer in1 = new Integer(num1);

②包装类转换成基本数据类型：调用包装类的xxxValue()

Integer in1 = new Integer(10);
//包装类转换成基本数据类型
int i = in1.intValue();

3、JDK5.0新特性：自动装箱与自动拆箱

int num1 = 10;
Integer in1 = num1;//自动装箱

int num2 = in1;//自动拆箱

4、基本数据类型、包装类转换成String类型

//方式一：连接运算
int num1 = 10;
String str1 = num1 + "";
//方式二：调用String的ValueOf(Xxx xxx)
float f1 = 12.3f;
String str2 = String.ValueOf(f1);

5、String类型转换成基本数据类型、包装类

//调用包装类的parseXxx(String s)
String str1 = "123";
int num2 = Integer.parseInt(str1);

六、 static关键字

1、static可以修饰：属性、方法、代码块、内部类
2、用static修饰属性：静态变量(或类变量)
实例变量：我们创建了类的多个对象，每个对象都独立有一套类中的非静态属性。当修改一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改后的。
说明： ①静态变量随着类的加载而加载，可以通过“类.静态变量”的方式进行调用
②静态变量的加载早于对象的创建
③由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
3、用static修饰方法：静态方法
①随着类的加载而加载，可以通过“类.静态方法”的方式进行调用
②静态方法中，只能调用静态的方法或属性
非静态方法中：即可以调用非静态的方法或属性，也可以调用静态的方法或属性
注意：在静态的方法内，不能使用this关键字，super关键字

七、main()方法的说明

1、main()方法作为程序的入口
2、main()方法也是一个普通的静态方法
3、main()方法可以作为我们与控制台交互的方式。(之前：使用Scanner)

八、代码块(初始化块)

1、代码块作用：用来初始化类和对象
2、代码块如果有修饰的话，只能使用static
3、分类：静态代码块和非静态代码块
(1)静态代码块：
①内部可以有输出语句
②随着类的加载而执行，而且只执行一次
③作用：初始化类的信息
④如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
⑤静态代码块优先于非静态代码块的执行
⑥静态代码块中，只能调用静态的方法或属性
(2)非静态代码块：
①内部可以有输出语句
②随着对象的创建而执行
③没创建一个对象就执行一次非静态代码块
④作用：可以在创建对象时，对对象的属性等进行初始化
⑤如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
⑥非静态代码块中，即可以调用非静态的方法或属性，也可以调用静态的方法或属性

public class Person {
    //属性
    private int age;
    private String name;
    //静态代码块
    static{
    //执行语句
    }
    //非静态代码块
    {
    //执行语句
    }
    //构造器
    public void Person(){

    }
    //方法
    public void say(){
        System.out.println("说话");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}

代码执行顺序： 由父及子，静态先行
属性赋值的先后顺序
①默认初始化
②显示初始化 / 在代码块中赋值(两者谁写在下面谁会给属性赋值)
③构造器中初始化
④有对象后通过“对象.属性”赋值

九、final关键字

1、final可以修饰类、方法、变量
2、final修饰类：此类不能被其他类继承，例如String类
3、final修饰方法：表明此方法不能被重写
4、final修饰变量：此时的“变量”就称为是一个常量
①final修饰属性：可以考虑赋值的位置有：显示初始化 、 在代码块中赋值、构造器中初始化
②final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量，当我们调用此方法时，给常量赋一个实参，一旦赋值以后就只能在方法体内使用此形参，但不能进行重新赋值。

十、抽象方法、抽象类

1、abstract关键字：可以修饰方法、类
2、abstract修饰类：抽象类
①此类不能实例化
②抽象类中一定有构造器，便于子类实例化时调用
③开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作
3、abstract修饰方法：抽象方法
①抽象方法只有方法的声明没有方法体

//抽象方法
public abstract void eat();

②包含抽象方法的类一定是抽象类，但是抽象类中可以没有抽象方法
③若子类重写了父类的所有抽象方法后，此子类方可实例化，若子类没有重写父类的所有抽象方法，则子类也是一个抽象类，需要使用abstract修饰。
4、abstract关键字使用的注意点：
①abstract不能用来修饰：属性、构造器等结构
②abstract不能用来修饰：私有方法、静态方法、final的方法、final的类

十一、接口

1、接口用interface来定义

//接口的定义
interface eat{

}

2、Java中接口和类是并列的两个结构
3、如何定义接口：定义接口中的成员

①JDK7及以前：

全局变量：public static final的，但是书写时，可以省略不写
抽象方法：public abstract的
②JDK8
除了定义全局变量和抽象方法之外，还可以定义，静态方法，默认方法

4、接口中不能定义构造器，意味着接口不可以实例化
5、Java开发中，接口通过让类去实现(implements)的方式来使用

如果实现类覆盖了接口中所有的抽象方法，则此实现类可以实例化
如果实现没有类覆盖了接口中所有的抽象方法，则此实现类仍为一个抽象类

6、Java类可以实现多个接口

格式：class AA extends BB implements CC,DD

7、接口和接口之间可以继承，而且可以多继承

Java8中的接口

1、接口中定义的静态方法，只能通过接口调用“接口.方法”
2、通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
3、如果子类(实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法-----类优先原则
4、如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写的此方法的情况下，报错----接口冲突，此时需要我们必须在实现类中重写此方法。
5、如何在子类(实现类)的方法中调用父类、接口中被重写的方法

//调用父类中声明的方法
super.method;
//调用接口中声明的默认方法
//接口.super.method;
AA.super.method;

十二、内部类

1、Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B就是外部类
2、内部类的分类：成员内部类(静态、非静态)、局部内部类(方法内、代码块内、构造器内)
3、成员内部类

作为类的成员

调用外部类的结构
可以被static修饰
可以被四种不同权限修饰

作为一个类

类内可以定义方法、属性、构造器等
可以被final修饰，表示此类不能被继承，不使用final修饰可以被继承
可以被abstract修饰

4、实例化内部类

//静态成员的内部类
Person.Dog dog = new Person.Dog();
//非静态成员的内部类
Person p = new Person();
Person.Bird bird = p.new Bird();