java基础—面向对象

一、面向对象

面向对象的概念：面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。（面向对象是一种以执行功能的对象为主体的思想）
面向对象的特点：是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者。
面向对象的特征：封装（encapsulation），继承（inheritance），多态（polymorphism）。

1.1 封装

概念：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
1. 将变化隔离。
2. 便于使用。
3. 提高重用性。
4. 提高安全性。
封装原则：
1. 将不要对外提供的内容都隐藏起来。
2. 把属性都隐藏，提供公共方法对其访问。如：getXXX，setXXX。

1.2 继承

描述的描述：
- 通过extends关键字让类与类之间产生继承关系。
- 多个类有相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。
- 子类无法继承父类中的私有类容。
继承的优点：
- 继承的出现提高了代码的复用性。
- 继承的出现让类与类之间产生了关系，提供了多态的前提。
继承的的特点：
- java只支持单继承，不支持多继承。
- 一个类只有一个父类，不可以有多个父类。
- java支持多层继承（继承体系）
函数覆盖：
- 当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象称为覆盖操作，这是函数在子父类中的特性。
- 在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获得。
示例：
- 代码：

class Person 
{
    String name;
    int age;
    void study()
    {
        System.out.println("Person……"+age);
    }
}
//Student继承了Person类
class Student extends Person
{
    //继承了父类中的成员变量
    //复写了Person类中study方法
    void study()
    {
        System.out.println("student study……"+age);
    }
}
class ExtendDemo
{
    public static void main(String args[])
    {
        Student s=new Student();
        s.name="张三";
        s.age=20;
        s.study();
    }
}

输出结果：

1.3 多态

定义：某一类事物的多种存在形式。
体现：父类或者接口的引用指向或者接收自己的子类对象。
作用：多态的存在提高了程序的扩展性和后期可维护性。
前提：
1. 需要存在继承或者实现关系。
2. 需要有覆盖操作。
好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。
多态时，成员的特点：
1. 成员变量
  - 编译时：参考引用型变量所属的类中是否有调用的成员变量。有，编译通过，没有，编译失败。
  - 运行时：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。
  - 简单说：编译和运行都参考等号的左边。
2. 成员函数（非静态）
  - 编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过，没有，编译失败。
  - 运行时：参考的对象所属的类中是否有调用的函数。
  - 简单说，编译看左边，运行看右边。
3. 静态函数
  - 编译时：参考的是对象所属的类中是否有调用的函数。
  - 运行时：参考的是对象所属的类中是否有调用的函数。
  - 简单说：编译和运行看左边。
示例：
- 代码：

class Fu
{
    int age=40;
    public static void see()
    {
        System.out.println("张父");
    }
}
//继承Fu类
class Zi extends Fu
{
    int age=4;
    public static void see()
    {
        System.out.println("张三");
    }
}
class  Demo
{
    public static void main(String[] args) 
    {
        //多态，父类引用接收子类对象 
        Fu x=new Zi();
        //静态函数编译和运行时都看父类引用
        x.see();
        //成员变量编译和运行时都看父类引用
        System.out.println(x.age);
    }
}

输出结果

二、类与对象

类的定义：类是具体事物的抽象描述，概念上的定义。
对象的定义：对象即是该类事物实实在在存在的个体。
类与对象的关系：类是对象的抽象，对象是类的实例。

2.1 内部类的介绍

定义：将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。
访问的特点：
- 内部类可以直接访问外部类中的成员，包含私有成员。
- 而外部类要访问内部类中的成员必须要建立内部类的对象。
内部类的位置：内部类定义在成员位置上，可以被private、static修饰。被static修饰的内部类只能访问外部类中的静态成员。

2.2 匿名内部类

定义：就是内部类的简化写法。
前提：内部类可以继承或实现一个外部类或接口。
格式：new 外部类名或者接口名（）{覆盖类或者接口中的代码，（也可以自定义内容。）}
简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。

2.3 接口

接口的定义：当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。
格式：interface{}
接口中的成员修饰符是固定的：
- 成员常量：public static final
- 成员函数：public abstract
- 接口中的成员都是公共的权限。
特点：
- 接口是对外暴露的规则。
- 接口是程序的功能扩展。
- 一个类可以实现多个接口。
综合案例
- 代码：

//实现功能的扩展。
interface USB
{   
    //暴露的原则
    public abstract void open();
    public abstract void close();   
}
//实现的原则
//降低了耦合性
class Upan implements USB
{
    public void open()
    {
        System.out.println("Upan open");
    }
    public void close()
    {
            System.out.println("Upan close");
    }
}
class UsbMouse implements USB
{
    public void open()
    {
        System.out.println("UsbMouse open");
    }
    public void close()
    {
        System.out.println("UsbMouse close");
    }
}
class  PC 
{
    public static void main(String[] args) 
    {
        //功能扩展了
        UseUSB(new UsbMouse());
    }
    //使用原则
    public static void UseUSB(USB u)//接口类的引用，用于接收（指向）接口的子类对象
     {
        if(u!=null);
        {
            u.open();
            u.close();
        }
    }
}

输出结果：

2.4 对象

对象的产生：创建对象的根本途径是构造器（特殊的方法），通过new关键字来调用某个类的构造器即可创建这个类的实例。
匿名对象：
- 对象的简化形式（一个没有名字的对象, 创建了一个对象出来,没有赋给一个变量）
- 使用情形：
  1. 当对对象方法仅一次调用时。
  2. 作为实际参数进行传递时。

2.5 成员变量和静态变量的区别

1. 两个变量的生命周期不同：

成员变量随着对象的创建而存在，随着对象被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。

2. 调用方式不同：

成员变量只能被对象调用。
静态变量既可以被对象调用也可以被类调用。

3. 别名不停：

成员变量也称为实例变量。
静态变量也称为类变量。

4. 数据储存位置不同：

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
静态变量数据存储在方法区（共享数据区）的静态区，所以叫数据的共享数据。

三、构造函数和构造代码块

3.1 构造函数

特点：
1. 函数名与类名相同。
2. 不用定义返回值类型。
3. 没有具体的返回值。
作用：给对象进行初始化。

3.2 构造代码块

作用：可以给所有对象进行初始化。

四、单例设计模式

概念：单例设计模式就是保证一个类在内存中的对象唯一性。
实现步骤：
1. 私有化该类构造函数。
2. 通过new在本类中创建一个本类对象。
3. 定义一个公有的方法，将创建的对象返回。

4.1 饿汉式

代码：

    class Single
    {
        //对构造函数进行私有化，无法在其它类中创建对象
        private Single(){}
        //在本类中创建一个本类对象
        private static Single s=new Single();
        //提供一个方法，将创建的对象返回
        public static Single getInstance()
        {
            return s;   
        }
    }

    class SingleDemo 
    {
        public static void main(String[] args) 
        {
            Single s1=Single.getInstance();
            Single s2=Single.getInstance();
            //s1，s2为同一个对象
            System.out.println(s1==s2);
        }
    }

输出结果：

4.2 懒汉式

代码：

    class Single1
    {
        private Single1(){}
        //延迟加载形式，只有调用了getInstance方法时，才会创建对象。
        private static Single1 s =null;
        public static Single1 getInstance()
        {
            if(s==null)
                s=new Single1();
            return s;
        }
    }
    class SingleDemo1
    {
        public static void main(String args[])
        {
        Single1 s1=Single1.getInstance();
        Single1 s2=Single1.getInstance();
        //s1，s2为同一个对象
        System.out.println(s1==s2);
        }
    }

输出结果：

Java基础---面向对象

java基础—面向对象

一、面向对象

1.1 封装

1.2 继承

1.3 多态

二、类与对象

2.1 内部类的介绍

2.2 匿名内部类

2.3 接口

2.4 对象

2.5 成员变量和静态变量的区别

三、构造函数和构造代码块

3.1 构造函数

3.2 构造代码块

四、单例设计模式

4.1 饿汉式

4.2 懒汉式

猜你喜欢