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. 减少重复代码

你可能感兴趣的:(多态,面向对象编程,java,封装)