Java基础学习笔记(二) - 面向对象基础

面向对象

一、面向对象概述　　

　　面向对象思想就是在计算机程序设计过程中，参照现实事物，将事物的属性特征、行为特征抽象出来，描述成计算机时间的设计思想。面向对象思想区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

　　特点：将复杂的事情简单化，抽象化。

　　三大基本特征：封装，继承，多态。（后面具体介绍）

　　类和对象：类是属性（成员变量）和行为（成员方法）的集合，对象是类的一个实例。

public class oop {
    int a; //a是一个成员属性    成员属性位于类中方法外
    public void method(){
        System.out.println("这是一个成员方法");
    }
}

public class TestOop {
    public static void main(String[] args){
        oop oop1 = new oop();//实例化oop类为oop1对象
        oop1.a = 1;//为成员属性赋值
        oop1.method();//调用成员方法

    }
}

　　关于static静态关键字：用来修饰静态变量或方法。静态变量由于不属于任何实例对象，是属于类的，所以在内存中只会有一份，在类的加载过程中，JVM为静态变量分配一次内存空间。

　　成员变量默认类型：

　　内存：实例化的过程在栈内存中，实例化的对象存在于堆内存中，同时调用多个对象的方法时如果指向的是同一方法，方法只会保存一次，以节约内存空间。

　　成员变量和局部变量：

• 成员变量：位于类中方法外（堆内存），作用域类中，初始化时有默认值，实例化对象时生成，对象消失成员变量消失。
• 局部变量：位于类方法中（栈内存），作用域方法中，无默认值，必须先定义赋值，才能使用，调用方法时生成，方法调用完毕消失。　

二、封装　　

　　封装会保护类中的成员属性，外部无法操作和修改，防止该类的代码和数据被其他类随意访问。必须通过指定的方式才能访问。

　　作用：适当的封装可以让代码更容易理解和维护，也加强了代码的安全性。

　　原则：保护成员属性，外部无法访问，若需访问，提供公共方法对其访问。

　　封装步骤：

• • 使用private关键字来修饰成员变量。（private是一个权限修饰符，表示最小权限，用来修饰成员变量和成员方法，被private修饰后的成员变量和成员方法，只有在本类中才能访问。）
  • 若需访问成员变量，提供相应类方法。

　　void关键字表示方法返回结果类型。（无return时写void）

　　this关键字表示类的当前对象的引用。

　　构造方法：当一个对象被创建时，构造方法用来初始化该对象，给对象的成员变量赋值初始值。　（构造方法可以被重载）

public class oop {
    private int a; //a是一个私有成员变量

    //构造方法
    public oop(){};//原始构造方法（系统提供）
    public oop(int a){//带参数构造方法（如果提供了构造方法，系统将不再提供无参构造方法）
        this.a = a;
    }

    public int getA(){ //通过getA成员方法访问a
        return a;
    }
    public void setA(int n) { //通过setA成员方法修改a
        a = n;

    }
}

　　标准代码--JavaBean：是Java编写类的一种标准规范。要求类必须是具体的和公共的，并且具有无参构造方法，提供用来操作成员变量的set和get方法。

public class oop {
    //成员变量
    //构造方法
    //无参（必须）
    //有参（非必须）
    //成员方法
    //get
    //set
}

三、继承

为什么使用继承？

　　多个类中存在相同属性和行为时，将这些内容抽取到一个单独的类中，那么多个类无需再定义这些属性和行为，只需要继承这个类即可。　

定义：继承就是子类继承父类的属性和方法，使子类具有与父类相同的属性和方法。子类可以直接访问父类中的非私有属性和方法。

作用：提高代码的复用性，使类与类之间产生关系，是多态（多种方法和属性）的前提。

用法：使用 extends 关键字。

class Father {
    //父类
}
class son  extends  Father{
    //子类
}

特点

• 成员变量：子类访问父类的成员变量时，使用super关键字（super.成员变量）。
• 成员方法：子类中出现和父类相同（返回值类型，函数名和参数列表全部相同）的成员方法时，子类会重写父类的成员方法。（重写要求子类方法权限必须大于父类）
• 构造方法：子类无法继承父类构造方法，需要使用super（），表示调用父类的构造方法。
• Java中每个类只能继承一个父类（单继承），一个父类可以被多个子类继承（多层继承）。

四、多态

定义：多态是指同一方法，具有多个不同表现形式。主要表现为继承或实现方法的重写，可以使程序编写的更简单，并有良好的扩展性。

public abstract class Father {　　　　　　　　　　//父类 abstract用于修饰类和方法，表示抽象类和方法（下一章介绍）
    public abstract void  say();
}

public class son1 extends  Father{　　　　　　　　//子类
    public void say(){
        System.out.println("我是儿子1");
    }
}
public class son2 extends Father{
    public void say(){
        System.out.println("我是儿子2");
    }
}

public class Test {
    public static void main(String[] args){
        Father f1 = new son1();       //多态调用
        Father f2 = new son2();

        sonSay(f1);　　　　//将对象传递给成员方法
        sonSay(f2);
    }
    public static void sonSay(Father f){
        f.say();
    }

}

多态的转型

　　引用类型转换分为向上转型和向下转型两种。

• • 多态本身是子类类型向父类类型向上转换的过程（默认）。
  • 父亲类型向子类类型转换被称为向下转换，属于强制类型转换。　　

public class Test {
    public static void main(String[] args){
        //默认向上转型 son1类型转换为Father
        Father f1 = new son1();
        //主动向下转型
        son1 s1 = (son1)f1;

    }

}

为什么要转型？

　　多态方式调用时，默认向上转型父类类型，如果子类拥有父类没有的方法，调用该方法就会发生编译错误，想要调用子类的特殊方法，必须向下转型。

转型注意

　　转型不能指向其他子类（如上面代码中的 f1和son2的关系），否则会造成编译错误。因为这两个子类并没有继承关系，不符合类型转换的定义。

　　这里可以使用 instanceof 关键字检测变量类型，相同为true，不同为false。

public class Test {
    public static void main(String[] args){

        Father f1 = new son1();
        if (f1 instanceof son1){      //true
            System.out.println("son1");
        }else if(f1 instanceof son2){ //false
            System.out.println("son2");
        }
    }
}

温馨提示

• 如果您对本文有疑问，请在评论部分留言，我会在最短时间回复。
• 如果本文帮助了您，也请评论关注，作为对我的一份鼓励。
• 如果您感觉我写的有问题，也请批评指正，我会尽量修改。