Java面向对象

最新推荐文章于 2023-06-06 21:17:19 发布

海绵娃娃

最新推荐文章于 2023-06-06 21:17:19 发布

阅读量533

点赞数

文章标签： java

本文链接：https://blog.csdn.net/oneqinglong/article/details/60144110

版权

Java面向对象

1 面向对象基础: 类，对象，实例

//类
class Student(){
    //成员变量
    String name;

    //成员方法
    public void showName(){
        System.out.println("学生名字为:"+name);
    }
}

Student s=new Student();//对象
//s为实例

类是一种数据结构，是对事物的描述。
对象需要new出来，加载到堆中。
实例就是类的具体化。

在类中的定义都称之为成员。成员有两种：
1.成员属性：对应的就是事物的属性，用变量描述。
2.成员方法：对应的就是事物的行为，用函数描述。

1.1 成员属性

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

成员属性 直接定义在类中。
局部变量 定义在方法中，参数上，语句中。
成员属性 在这个类中有效。
局部变量 只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。
成员属性 存在于堆内存中，随着对象的产生而存在，消失而消失。
局部变量 存在于栈内存中，随着所属区域的运行而存在，结束而释放。

1.2 成员方法=构造方法(构造代码块)+一般方法

1.2.1 构造方法

定义:
用于给对象进行初始化，是给与之对应的对象进行初始化。
特点：
1、该方法的名称和所在类的名称相同。
2、不需要定义返回值类型。
3、该方法没有具体的返回值。
记住：
所有对象创建时，都需要初始化才可以使用。
类中没有构造方法：
一个类在定义时，如果没有定义过构造方法，那么该类中会自动生成一个空参数的构造方法，为了方便该类创建对象，完成初始化。如果在类中自定义了构造方法，那么默认的构造方法就没有了。
类中多个构造方法
一个类中，可以有多个构造方法，因为它们的方法名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造方法。它们的存在是以重载体现的。

1.2.2 构造方法和一般方法的区别

定义格式不同
调用方式不同 :
构造方法是在对象创建时，就被调用，用于初始化。
一般方法是对象创建后，需要调用才执行。
执行次数不同:
构造方法的初始化动作只执行一次。
一般方法可以被调用很多次。

2 面向对象三大特征: 封装，继承，多态

2.1 封装

封装的定义 :
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装的好处：
将变化隔离；便于使用；提高重用性，安全性。
封装的原则：
将不需要对外提供的内容都隐藏起来，提供公共方法对其访问。
封装的体现：
私有仅仅是封装的一种体现形式而已。
属性是用于存储数据的，直接被访问，容易出现安全隐患。
所以，类中的属性通常被私有化，并对外提供公共的访问方法。
对于私有属性的访问方位一般有两个:setter(),getter()。

匿名对象

使用场景：
1、当对方法只进行一次调用的时候，可以使用匿名对象。
2、当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。

2.2 继承

继承体现了复用性原则。
继承的弊端是打破了封装性。
单继承：一个类只能有一个父类。Java只支持单继承。
多继承：一个类可以有多个父类。Java不直接支持类的多继承。

为什么不支持多继承？

因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？但是Java支持多重继承。A继承B B继承C C继承D。

继承情况中，成员的特点:

成员属性
- 父类和子类中出现同名变量，子类调用，值是子类的
- 父类和子类中一般不会出现同名变量，因为父类中有，子类中继承即可。
成员方法
- 父类和子类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。这叫做重写(覆盖，覆写)。重写体现了扩展性原则。
- 子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。
- 覆盖时，要么都静态，要么都不静态。静态只能覆盖静态，或者被静态覆盖。
构造方法
- 发现子类构造方法运行时，先运行了父类的构造方法。
  原因：子类的所有构造方法中的第一行，其实都有一条隐身的语句super();
- super(): 表示父类的构造方法，并会调用于参数相对应的父类中的构造方法。
- 为什么子类对象初始化时，都需要调用父类中的方法？
因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造方法，这就是子类的实例化过程。

注意事项：
- 子类中所有的构造方法都会默认访问父类中的空参数的构造方法，因为每一个子类构造内第一行都有默认的语句super();
- 如果父类中没有空参数的构造方法，那么子类的构造方法内，必须通过super语句指定要访问的父类中的构造方法。
- 如果子类构造方法中用this来指定调用子类自己的构造方法，那么被调用的构造方法也一样会访问父类中的构造方法。
2.3 多态
- 多态定义
  - 父类引用或者接口的引用指向了自己的子类对象。Animal a = new Cat();
  - 可以调用子类中重写的方法。
- 多态的前提
  - 必须要有关系，比如继承、或者实现。
  - 通常会有覆盖操作。
- 多态的好处：提高了程序的扩展性。
- 多态的弊端：
  - 当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)
  - 如果想用子类对象的特有方法，如何判断对象是哪个具体的子类类型呢？
    可以通过一个关键字 instanceof ,用来判断对象是否实现了指定的接口或继承了指定的类。
  - 格式：<对象 instanceof 类型> ，判断一个对象是否所属于指定的类型。
```
Student instanceof Person = true;//student继承了person类
```
- 多态的代码
```
class A1{
    void teaching(){
        System.out.println("教课");
    }

    void fishing(){
        System.out.println("钓鱼");
    }
}

class A11 extends A1{

    void teaching(){
        System.out.println("JAVA");
    }

    void watching(){
        System.out.println("看电影");
    }
}

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

        A1 x = new A11();//向上转型 子-->父 
        x.teaching();
        x.watching();  //错误,不能访问的。
        A11 y = (A11)x; //向下转型 父-->子
        y.watching();
        //在多态中，自始自终都是子类对象在做着类型的变化。
    }
}   
```
封装：隐藏实现细节，让代码模块化。体现复用性(模块化)原则。
继承：扩展已经存在的代码模块(类)。体现扩展性原则。
多态：在继承的基础上，让子类功能能被父类引用变量调用(向后兼容)。进一步体现扩展性(降低耦合性)原则。

2.4 关键字： this-super-static-final

this关键字
this代表本类对象。
this可以调用成员。包括成员属性和成员方法(一般方法和构造方法)。
```
public class Student{
    String name;

    //构造方法一
    public Student(){
        //注意：用this调用构造方法，必须定义在构造方法的第一行。
        this("张三")
    }

    //构造方法二 
    public Student(String name){
        this.name=name;
    }
}
```
super关键字

this：代表是本类类型的对象引用。
super：代表是子类所属的父类中的内存空间引用。
- super()和this()是否可以同时出现的构造方法中？
  两个语句只能有一个定义在第一行，所以只能出现其中一个。
- super()或者this():为什么一定要定义在第一行？
  因为super()或者this()都是调用构造方法，构造方法用于初始化，所以初始化的动作要先完成。
static关键字
static是一个修饰符。
用于修饰成员。包括成员属性和成员方法。
体现了复用性原则。
- 特点：
  - 想要实现对象中的共性数据共享。可以将这个数据进行静态修饰。
  - 被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态成员。
  - 静态随着类的加载而加载。而且优先于对象存在。
- 注意：
  - 有些数据是对象特有的数据，是不可以被静态修饰的。
  - 静态方法只能访问静态成员，不可以访问非静态成员。
    因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
  - 静态方法中不能使用this，super关键字。
    因为this代表对象，而在静态时，有可能没有对象，所以this无法使用。
  - 主方法是静态的。
- 成员属性和静态变量的区别：
  - 成员属性所属于对象。所以也称为实例变量。
    静态变量所属于类。所以也称为类变量。
  - 成员属性存在于堆内存中。
    静态变量存在于方法区中。
  - 成员属性随着对象创建而存在。随着对象被回收而消失。
    静态变量随着类的加载而存在。随着类的消失而消失。
  - 成员属性只能被对象所调用。
    静态变量可以被对象调用，也可以被类名调用。
  - 成员属性可以称为对象的特有数据，静态变量称为对象的共享数据
final关键字
final是一个修饰符，可以修饰类，方法，变量。
- 被final修饰的类是一个最终类，不可以被继承。
- 被final修饰的方法是一个最终方法，不可以被覆盖。
- 被final修饰的变量是一个常量，只能赋值一次。
- 不加final修饰不是也可以使用吗？那么这个值是一个变量，是可以更改的。加了final，程序更为严谨。常量名称定义时，有规范，所有字母都大写，如果由多个单词组成，中间用 _ 连接。
3 抽象类和接口

3.1 抽象类: abstract
- 抽象类的特点：
  - 抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
  - 抽象方法只定义方法声明，并不定义方法实现。
  - 抽象类不可以被创建对象(实例化)。
  - 只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
- 抽象类的细节：
  - 抽象类和一般类没有太大的区别，都是在描述事物。
  - 抽象类中可以有构造方法。
  - 抽象类中可以有一般方法。
  - 抽象关键字abstract和哪些不可以共存？final , private , static
  - 抽象类中可以不定义抽象方法。
    抽象方法目的仅仅为了不让该类创建对象。
3.2 接口

接口的定义
1. 是用关键字interface定义的。
2. 接口中包含的成员，最常见的有全局常量、抽象方法。
注意：接口中的成员都有固定的修饰符。
成员属性：public static final
成员方法：public abstract
```
interface Inter{
    public static final int x = 3;
    public abstract void show();
}
```
接口的特点
1. 接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
2. 类与类之间存在着继承关系，类与接口中间存在的是实现关系。即继承用extends ；实现用implements ；
3. 接口和类不一样的地方是接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多实现来体现。
4. 一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。
5. 其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。
6. 接口都用于设计上，设计上的特点：（可以理解主板上提供的接口）
- 接口是对外提供的规则。
- 接口是功能的扩展。
- 接口的出现降低了耦合性。
抽象类与接口
- 抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取。特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。
- 接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。
- 抽象类和接口的共性：都是不断向上抽取的结果。
- 抽象类和接口的区别：
  - 抽象类只能被继承，而且只能单继承。接口需要被实现，而且可以多实现。
  - 抽象类中可以定义非抽象方法，子类可以直接继承使用。接口中都是抽象方法，需要子类去实现。
  - 抽象类的成员修饰符可以自定义。接口中的成员修饰符是固定的。全都是public的。
4. 包和常见的软件包

4.1 包：定义包用package关键字。
- 给类文件提供多层名称空间。
  如果生成的包不在当前目录下，需要最好执行classpath，将包所在父目录定义到classpath变量中即可。
- 类的全名称是：包名.类名
  编译命令：javac –d 位置（.当前路径） java源文件（就可以自动生成包）
- 包是一种封装形式，用于封装类，想要被包以外的程序访问，该类必须为public；类中的成员，如果被包以外访问，也必须public；
- 包与包之间访问可以使用的权限有两种：
  - public
  - protected：只能是不同包中的子类可以使用的权限。
总结java中的四种权限：

范围 public protected default private
同一个类中 ok ok ok ok
同一包中 ok ok ok
子类 ok ok
不同包中 ok

import - 导入：类名称变长，写起来很麻烦。为了简化，使用了一个关键字：import，可以使用这个关键字导入指定包中的类。记住：实际开发时,到的哪个类就导入哪个类，不建议使用*.
import packa.*: 这个仅仅是导入了packa当前目录下的所有的类。不包含子包。
import packa.abc.*: 导入了packa包中的子包abc下的当前的所有类。如果导入的两个包中存在着相同名称的类。这时如果用到该类，必须在代码中指定包名。

4.2 常见的软件包:
- java.lang : language java的核心包，Object System String Throwable jdk1.2版本后，该包中的类自动被导入。
- java.awt : 定义的都是用于java图形界面开发的对象。
- javax.swing: 提供所有的windows桌面应用程序包括的控件,比如：Frame , Dialog, Table, List 等等,就是java的图形界面库。
- java.net : 用于java网络编程方面的对象都在该包中。
- java.io : input，output 用于操作设备上数据的对象都在该包中。比如：读取硬盘数据，往硬盘写入数据。
- java.util : java的工具包，时间对象，集合框架。
- java.applet :
  - application+let –>客户端java小程序。
  - server+let –> servlet 服务端java小程序。
- jar ：java的压缩包，主要用于存储类文件，或者配置文件等。
  - 命令格式：jar –cf 包名.jar 包目录
  - 解压缩：jar –xvf 包名.jar
  - 将jar包目录列表重定向到一个文件中：jar –tf 包名.jar >c:\1.txt