javaSE1.7面向对象编程

面向对象

思想：分类的思想，物以类聚

oop（面向对象编程）（object-oriented-programing）

本质：以类的方式组织代码，以对象的组织封装数据；

抽象：

三大特性：封装

​ 继承

​ 多态

方法

静态方法 static

类名.方法名

非静态方法：

对象.方法名

一个类中两个静态方法，两个非静态可以相互调用，静态方法不可以直接调用非静态方法

实参和形参类型要一致

类和对象的关系

类是抽象的的数据类型：类是抽象概念的具体实例；

类是对象模板‘

类：

1. 属性
2. 方法

使用new关键字进行创建对象时，除了分配内存单元，还会进行默认的初始化以及对类的构造起的调用。

构造器

类的构造器也叫构造方法，是进行创建对象时必须调用的，有以下两个特点：

1. 必须和类名相同

2. 必须没有返回类型，也不能写void

3. 会默认给程序分配构造器。

   this.name = name 前面的表示类本身的，后面的表示参数传进来的。

   使用new关键字必须有构造器，本质是在调用构造器。

   用构造器用来初始化值。

//一旦有了有参构造，如果使用无参构造就必须显示无参构造定义。

对象是通过引用来操作的 ：栈---->堆

默认初始化：

1. 数字：0，0.0
2. char：u0000
3. Boolean：false
4. 引用：null

封装

程序设计要求：高内聚，低耦合；

高内聚：类的内部操作细节自己完成，不允许外部干涉：

低耦合：及暴露少量方法给外部使用；

get/set方法：应对private的修饰的成员变量；

public String getName(){

return this.name;}

public void setName(String name){

this.name =name;}

优点：

提高安全性，隐藏细节，统一接口，系统可维护增加。

继承

extends，

是子类对父类的继承；

java只有单继承没有多继承。

子类继承父类会拥有父类的全部方法（公有地）。

在Java中都默认继承object类

super

注意点

1. super调用父类的构造方法，必须在构造方法的第一个。
2. super必须只能在子类的方法或者构造方法，
3. super和this不能能同时调用构造方法

VS this

代表的对象不同：

1. this：本身调用这个对象
2. super： 代表父类的对象的应用

适用前提：

this：没有继承可以使用

super：只能在继承时使用

构造方法：

this（）：本类的构造

super（）：父类的构造

方法重写（override）

重写只和非静态方法有关

需要有继承关系：

1. 方法名相同
2. 参数列表相同
3. 修饰符：范围可以扩大不能缩小：从父类到子类：：private -> default- >proteected->puplic
4. 抛出的异常：可以被缩小，不能被放大。
5. 方法体不同

重写指的都是方法的重写：

如果两个类有继承关系：则父类的引用可以指向子类

重写的理由：

父类的功能不要或者不满足

如果继承中，是静态方法，方法的调用只和左面（对象的定义的数据类型有关）

如果继承中，非静态方法，方法的调佣和右面有关（new）—方法的重写

多态

可实现动态编译

注意事项：

1. 多态是方法的多态
2. 父类和子类：有联系，如果没有联系报异常（classCastException)类型转化异常
3. 存在了条件：继承条件
4. 不能重写方法：static，final，private

一个对象的实际类型是确定的，但是指向对象的引用的类型很多（包括父类，子类）

public class Student extends Person{
    public void run(){
        System.out.print("run")
    }
    public void eat(){
        
    }
}
public class Person{
    pubulic void run(){
        
    }
}
public class Application{
    public static void main (){
        //new Student（）
        //new Person()
        //本身的类型是确定的
        Student s1 = new Student();
        Person  s2 = new Studnet();
        Object  s3 =new Student()
        //但是只想的引用类型不确定，可以指向本身类，也可以指向父类。
        s2.run() //执行结果没有被继承的话是父类的方法结果
            //如果被子类重写则输出子类结果
            ///因为子类继承父类的方法
        s2.eat()//没有结果，除非强制转化（Student)s2.eat()
            //因为父类没有这个方法
            ----------------------------------------------
            //对象能执行的方法看左面的类型和右面关系不大。
            //子类能调用的方法都是自己的和父类继承来的
            //父类可以指向子类类，但不能调用子类独有的方法。
            
            
       
    }
}

instanceof

是类型转化，判断对象属于那一个类或者父类，父父类

X instanceof Y能不能编译通过取决于父子关系，是true还是false取决于X所指的类型是不是Y的子类型。

类型转化

类型转化 父类（高） 子类（低）

person s1 = new Student() ; 或者 Person person = s1; ----低转高，自然转化

（Student)s2.eat() ----高转低,强制转化

Person person = s1;子类转化成父类，person.eat()// 不通过，因为会丢失一些方法

总结：

1. 父类引用指向子类对象
2. 父类转换成子类，向下转型（强制），丢方法
3. 子类转化成父类，向上转型（自然）
4. 减少重复代码