美文网首页
Java中的OOP

Java中的OOP

作者: 小石头呢 | 来源:发表于2019-08-11 18:12 被阅读0次

一.OOP

Java是一个面向对象程序设计(Object Oriented Programming,OOP)的语言

二.变量

1.成员:

  • 成员变量:独立于方法之外的变量,作用域是从对象开始创建到销毁

  • 成员函数:非构造函数外的类内部的函数

//参数确定
和C语言类似

//参数不确定
public int test6(int ... counts){
    int sum = 0;
    for (int i = 0; i < counts.length; i++) {
        sum += counts[i];
    }
    return sum;
}

2.变量类型:

  • 类变量:独立于方法之外的变量,用 static 修饰。

  • 实例变量:独立于方法之外的变量,不过没有 static 修饰。

  • 局部变量:类的方法中的变量。

3.构造方法:

  • 创建类的一个对象的时候,就会被调用的方法(就是初始化方法,相当于oc的init)。

  • 每个类会默认提供一个构造方法,没有返回值,名字是类名public 类名(){}

  • 构造方法的重载,重新写一个有参数的构造方法,在对象创建的时候,希望给属性赋值;或者希望在对象创建的时候做一点事情。

//类的默认构造方法
public Poker() {
    System.out.println("构造方法");
}

//构造方法的重载 自定义一个有参数的构造方法
//通常给一个属性赋值,形参名尽量与属性名一致
//方法里面的变量以及参数的作用域就在这个方法里面,出了方法就没有了
public Poker(String number,String color) {
    this.number = number;
    this.color = color;
    System.out.println("自定义的构造方法");
}

4.匿名对象:

  • 尽量少使用匿名对象,当做参数时,适合使用
//new String[]{"请输入玩家人数:"}就是匿名对象
Utils.log(false,false,new String[]{"请输入玩家人数:"});

三.类和对象

1. 类

  • 抽象的,不存在的,用来描述同一类事物
  • 具有共同的方法和属性,不能完成具体的事情
  • 同一个方法可以有多个对象,每个对象的内存空间都是独立的(对象之间没有任何关系)
  • 定义一个类(类名必须大写),通常情况下一个文件对应一个类
修饰符 class 类名{
   这个类的一些属性:成员变量
   这个类的功能:方法
}

明确
存什么值:成员变量
完成什么功能:方法

2. 对象

  • 对象都是new出来的,有内存空间
  • 具体的,实际存在的,某一类的实例化,可以完成具体的事情

3. 实例方法的调用

  • 首先思考调用谁的(哪个对象)方法
  • 在类里面可以直接调用自己的方法
  • 在外部必须通过对象来调用

4. 给对象属性赋值的方式

  • 对于public,protected,default修饰的属性,使用对象直接用.调用。
  • 对于private修饰的属性 不能直接调用,只能用 setter/getter方法间接调用。
  • 给外部提供一个setter方法,通过这个方法给某个变量赋值;可以对外部给的值产生控制。
  • 给外部提供一个get方法,通过这个方法访问某个变量;可以把给外部的值加密等其它操作。

5. 什么时候需要使用this

  • 需要明确指定调用的是这个对象自己的一些属性和方法
public Poker(String number,String color) {
    this.number = number;
    this.color = color;
    System.out.println("自定义的构造方法");
}
  • 某一个方法里面调用this,this指的是调用这个方法的对象
public void setColor(String color) {
        this.color = color;
}

Poker poker = new Poker();
poker.setColor("♥");

这里的this就是poker对象

6. 重写类的toString方法

  • 所有的类都是直接或者间接继承于Object,Object有一个方法:toString,用来打印对象。
public String toString() {
     return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
}
  • 我们测试的时候可以在我们的类中重写toString用来打印我们想要的对象的内容。
@Override
public String toString() {
    return "CivilServant{" +
            "salary=" + salary +
            ", count=" + count +
            ", name='" + name + '\'' +
            ", age=" + age +
            '}';
}

7.声明一个对象和实例化一个对象

  • 声明一个对象,并不会分配一个完整的对象所需要的内存空间,只是将对象名所代表的变量看成是一个引用变量,并为它分配所需内存空间,它所占用的空间远远小于一个类的对象所需要的空间。

  • 用new创建一个新对象,即为实例化。实例化的过程就是为对象分配内存空间的过程,此时,对象才成为类的实例。new所执行的具体操作是调用相应类中的构造方法(包括祖先类的构造方法),来完成内存分配以及变量的初始化工作,然后将分配的内存地址返回给所定义的变量。

四.面向对象的三大特性

封装Encapsulation

1.概念:将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来对隐藏的信息进行操作和访问。

2.好处:1.只能通过规定的方法访问数据;2.隐藏类的实例细节,方便修改和实现。

3.实现步骤:修改属性的可见性为private,创建getter/setter方法,用于访问数据,也可以在其中加入属性控制语句。

package swu.xl.day3.base;

public class Poker {
 
    private String number;
    private String color;

    public String getNumber(){

        return number;
    }

   public void setNumber(String number){
        this.number = number;
    }

   public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

继承

1.概念:继承就是子类继承父类的特征和行为,使得子类对象具有父类的属性和方法。

2.继承的特性:

  • 子类拥有父类非private的属性,方法。
  • 子类可以拥有自己的属性和方法,可以对父类进行扩展。
  • 子类可以用自己的方式实现父类的方法。
  • Java的继承是单继承,可以多重继承,不可以单继承。

3.继承的关键字:

  • 继承可以使用 extendsimplements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类

  • extends的使用
    在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}
  • implements的使用
    使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口
public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

4.super和this关键字

  • super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。

  • this关键字:指向自己的引用。

调用super对应方法的情况:
如果一个方法需要完成一个功能,又不能单独完成,必须要父类完成相应的工作
1.父类做完之后,子类再操作
2.子类做点事后,再调用父类完成

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

5.构造器:

  • 子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。

  • 如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

  • 如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器。

  • 如果父类的构造器既有带有参数,又有不带参数的,可以不显示的调用父类构造器

class SuperClass {
  private int n;

  public SuperClass(){
    System.out.println("SuperClass()");
  }

  public SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}

class SubClass extends SuperClass{
  private int n;
  
  public SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
//判断某个对象是不是某个类
对象 instanceof 类

多态polymorphic

1.两种表现形式:

  • 同一个方法在不同的子类中有不同的实现(子类继承父类后可以重写继承到的方法)
  • 如果有继承关系,子类的对象可以使用父类变量接受(类型的自动向上转换)

2.注意:
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

3.多态的实现方式:

  • 重写
  • 接口
  • 抽象类和抽象方法

相关文章

网友评论

      本文标题:Java中的OOP

      本文链接:https://www.haomeiwen.com/subject/ohgcjctx.html