Java—–面向对象

面向对象的思想：

面向对象和面向过程的区别：

面向对象的三大特点：

封装，继承，多态

封装性：

继承性：

多态性：

类与对象：

在面向对象中，为了做到让程序对事物的描述与事物在现实中形态保持一致，面向对象思想中提出了两个概念，即类和对象，在Java程序中类和对象是最基本，最重要的单元，类表示某类群体的一些基本特征抽象，对象表示一个个具体的事物。

例如：在现实生活中，学生就可以表示为一个类，而一个具体的学生，就可以称为对象，一个具体的学生会有自己的姓名和年龄等信息，这些信息在面对对象的概念中称为属性，学生可以看书和打篮球，而看书和打篮球这些行为在类中就成为方法。

他们之间的关系如下图所示：
上图所示中：

学生表示一个类，而小明，李华，大军则是学生这个类型的对象。

类用于描述多个对象的共同特征，它是对象的模板，例如小明，李华，大军的共同特征都是学生。

对象用于描述现实中的个体，它是类的实例，例如学生小明，李华，大军。

对象是根据类创建的，一个类可以对应多个对象，如上图所示，学生这个类创建了3个对象。

类的定义：

在面向对象的思想中最核心的就是对象，而创建对象的前提是需要定义一个类，类是Java中一个重要的引用数据类型，也是组成Java程序的基本要素，所有的Java程序都是基于类的。

定义格式如下：

class 类名{
成员变量； //用于描述对象的特征—–对象的属性
成员方法； //描述对象的行为——对象的行为
}

举例：

class Student{
    String name;//定义String类型的变量name
    int age;//定义int类型的变量age
    String sex;//定义String类型的变量sex
    //定义read()方法
    void read()
    {
        System.out.println("大家好，我是"+name+",我在看书!");
    }
}

局部变量和成员变量的区别：

在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。

定义的局部变量和成员变量同名，这种情况也是被允许的，此时，在方法中通过变量访问到的是局部变量，而并非成员变量。

举例：

class Student{
    int age=30;
    void read()
    {
        int age=50;//age此时被定义在方法中，因此是局部变量
        System.out.println("大家好，我"+age+"岁了,我在看书");
    }
}

此时不仅在方法read中有age这个变量，在该方法之外也有age这个变量，因此，如果此时，另外一个程序调用read()方法时，输出的值为50，而不是30

对象的创建：

在Java程序中，可以使用new关键字创建对象，具体格式如下：

类名 对象名称 =null；
对象名称=new 类名();

上述对象的创建过程为两个步骤，其实，也可以简化为一步，具体格式如下:

类名 对象名称=new 类名(）；

例如，我们现在创建一个Student类的实例对象，实例代码如下：

Student stu=new Student();//stu是Student类型的一个变量
//运算符”=”是将新创建的Student对象地址赋值给变量stu,变量stu引用的对象简称为stu对象

对象的使用：

class Student {
    String name;//属性----名字

    void read() {
        System.out.println("大家好，我是" + name + ",我在看书！");
    }

    public class Test {
        public static void main(String[] args) {
            Student stu = new Student();//创建并实例化对象
        }
    }
}

上述实例中，使用new关键字创建的对象是在堆内存分配空间，stu对象的内存分配如下图所示：

对象的使用：

当我们创建Student对象后，可以使用对象访问类中的某个属性或方法，对象属性和方法的访问通过“.”运算符实现。

语法格式如下：

对象名称.属性名
对象名称.方法名

举例：

class Student {
    String name;//属性----名字
    void read() {
        System.out.println("大家好，我是" + name + ",我在看书！");
    }
}

    public class student1 {
        public static void main(String[] args) {
        //创建并实例化对象
            Student stu1 = new Student();
            Student stu2=new Student();
            stu1.name="小明";//给name属性赋值
            stu1.read();//实例stu1访问read方法
            stu2.name="小张";
            stu2.read();//实例stu2访问read方法
        }
    }

输出：

大家好，我是小明,我在看书！
大家好，我是小张,我在看书！

此时内存变化如下所示：

对象的引用传递：

类属于引用数据类型，引用数据类型就是指在内存空间可以同时被多个栈内存引用。
举例：

class Student {
    String name;//属性----名字
    int age;//属性----年龄
    void read() {
        System.out.println("大家好，我是" + name + ",年龄"+age);
    }
}
    public class student1 {
        public static void main(String[] args) {
            Student stu1 = new Student();//创建并实例化对象
            Student stu2=null;//创建对象stu2，但不对齐进行实例化
            stu2=stu1;//stu1对象为stu2对象分配使用权
            stu1.name="小明";
            stu1.age=20;
            stu1.read();
            stu2.age=18;
            stu2.read();
        }
    }

输出：

大家好，我是小明,年龄20
大家好，我是小明,年龄18

下面我们对上述代码进行分析：

 Student stu1 = new Student();//创建并实例化对象
 Student stu2=null;//创建对象stu2，但不对齐进行实例化

为对象stu1分配内存空间，如下所示：

stu2=stu1;//stu1对象为stu2对象分配使用权

使stu1和stu2指向同一块内存：

stu1对象为属性赋值：

通过stu2修改age的值：

注：一个栈内存只能指向一个堆内存，如果想要再指向其他堆内存空间，就必须先断开已有的指向才能分配新的空间。

访问控制：

指针类，成员方法和属性，Java提供了四种访问控制权限。分别是private，default，protected和public。

这四种访问权限按级别由小到大依次排列：

private（当前类访问级别）：

private属于私有访问权限，用于修饰类的属性和方法，类的成员一旦使用了private关键字修饰，则该成员只能在本类中进行访问。

default：

如果一个类中的属性或方法没有任何的访问权限说明，则该属性或方法就是默认的访问权限，默认的访问权限可以被本包中的其他类访问，但是不能被其他包的类访问。

protected：

属于受保护的访问权限，一个类中的成员使用了protected访问权限，则只能被本包及不同包的子类访问。

public：

public属于公共访问权限，如果一个类中的成员使用了public访问权限，则该成员可以在所有的类中被访问，不管是否在统一包中。

通过下述图表更能直观的显示这几种访问控制：

举例：

public class student1
{
    public static void main(String[] args) {
    }
    public int a;//a可以被所有类进行访问
    protected boolean b;//可以被所有子类及本包的类使用
        void cc () {//未申明访问控制，因此为默认default-----能在本类使用
            System.out.println("包访问权限");
        }
        private class InnerClass {//访问控制为private----只能在本类中进行使用

        }
}

局部变量是没有访问权限控制的，因为局部成员只在其所在作用域起作用，不可能被其他类访问到。

举例：

如果一个Java源文件中定义的所有类都没有用public修饰，那么这个Java源文件的文件名可以是一切合法的文件名，如果源文件中定义了一个public修饰的类，那么这个源文件的文件名必须与public修饰的类名相同。

封装：

类的封装是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内部信息，而是通过该类提供的方法实现对内部信息的操作访问。

实现封装的原因：

在Java面向对象的思想中，封装是指一种将抽象性函数式接口的实现细节部分包装,隐藏起来的方法，封装可以被认为是一个保护屏障，防止本类的代码和数据被外部类定义的代码随机访问。

举例：

class student{
    String name;
    int age;
    void read() {
        System.out.println("大家好，我是"+name+",年龄"+age);
    }
}
public class student1{
    public static void main(String[] args) {
        student stu=new student();
        stu.name="张三";
        stu.age=-18;//将年龄赋值为负值
        stu.read();
    }
}

输出：

大家好，我是张三,年龄-18

虽然程序是成功通过编译的，但是年龄为负值，在现实生活中显然是不符合常规的，因此为了避免这种错误的发生，我们在设计类的时候，应该对成员变量的访问做出一些限定，不允许外界访问，这就需要实现类的封装。

实现封装的方法：

在Java中，在定义一个类时，将类中的属性私有化，即使用private关键字修饰类的属性，被私有化的属性只能在类中被访问，如果外界想要访问私有属性，则必须通过setter和getter方法设置和获取属性。

举例：

class student1 
{
    //声明名字和年龄都是私有属性
    private String name;
    private int age;
    
    public String getName() 
    { //获取名字
        return name;
    }

    public void setName(String name)
    {//设置名字
        this.name = name;
    }

    public int getAge() 
    {//获取年龄
        return age;
    }
    public void setAge(int age) 
    {//设置年龄
        if (age <= 0) 
        {
            System.out.println("您输入的年龄有误！");
        } 
        else 
        {
            this.age = age;
        }
    }
    public void read () 
    {
        System.out.println("大家好，我是" + name + ",年龄" + age);

    }
}

public class Example
{
    public static void main(String[] args)
    {
        student1 stu = new student1();//创建实例
        //调用方法，传递实参
        stu.setName("张三");
        stu.setAge(-18);
        stu.read();
    }
}

输出：

您输入的年龄有误！//年龄小于0时，提示错误
大家好，我是张三,年龄0