【Java学习】面向对象（一）

本文目录

前言

本文介绍了面向对象相关的基础知识，在此做一总结。

正文

一、三大特性

（1）封装性

面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。

（2）继承性

  • 继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。
  • 继承提高了代码复用性，提升了效率，对程序的修改补充提供了便利。

（3）多态性

多态性指的是在程序中允许出现重名现象，指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，使得同一个属性和方法在不同的类中具有不同的语义。

二、类与对象

（1）概念

  • 对象：用来描述客观事物的一个实体，由一组属性和方法构成。
  • 类：具有相同属性和方法的一组对象的集合。
  • 属性：对象具有的各种特征。
  • 方法：对象执行的操作。
  • 成员变量：定义在方法外，类内的变量被称为成员变量（全局变量）。
  • 局部变量：定义在方法内的变量被称为局部变量。
  • 栈：存放局部变量，方法执行完毕自动释放空间。
  • 堆：存放实例化出的对象，需要垃圾回收器回收。
  • 方法区：存放类的信息（代码）、static变量，字符串常量…。
注意：
-局部变量：

①作用域：从定义的位置开始到整个方法结束；
②局部变量只能在当前方法中使用；
③存放于栈内存中；
④没有默认值。

-成员变量：

①作用域：整个类体内；
②存放于堆内存中；
③有默认值。

（2）对象的创建

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

（3）类的设计

类+属性+方法

public class Student{
	String name;
	int age;
	public void introduce(){
		System.out.println("大家好，我叫"+name+"，我今年"+age+"岁");
	}
}

（4）类的封装

  • 在定义一个类时，将类中的属性私有化，即使用 private 关键字来修饰，私有属性只能在它所在的类中被访问。
  • 为了能让外界访问私有属性，需要提供一些使用 public 修饰的公有方法，其中包括用于获取属性值的 getXxx() 方法和设置属性值的 setXxx() 方法。

（5）引用

  • 引用可以理解为一种受限的指针；

  • 指针可以与整数做加减运算，两个指针直接也可以进行大小比较运算和加减运算。
    而引用不可以，只能进行赋值运算。

  • 引用就是一个变量或对象的别名（本质是一个对象）；
    指针是一个段内存空间的地址（指向存储一个变量值的空间或一个对象的空间）。

三、构造方法

（1）定义

在一个类中定义的方法，如果同时满足以下三个条件，该方法称为构造方法；
①方法名与类名相同；
②在方法名的前面没有返回值类型的声明；
③在方法中不能使用return语句返回一个值。

（2）构造方法的重载

①方法名相同
②参数项不同
③与返回值。访问修饰符无关。

  • 一旦为该类定义了构造方法，系统就不再提供默认的构造方法。

  • 在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。

  • 在一个类中可定义多个重名的构造方法，只要每个构造方法的参数类型或个数不同即可。

  • 每个类至少有一个构造方法，如果一个类中没有定义构造方法，系统会为这个类创建一个默认构造方法，默认构造方法没有参数。

四、this关键字

（1）定义

  • this存放在堆里，表示当前对象的指针，指向当前对象，表示当前对象的引用。

①构造方法：当构造方法中的参数名称跟类的成员变量名称一样的时候，可以使用this来代表当前对象
注意：有了this之后，可以将构造方法的参数跟成员变量保持一致
②普通方法：当多个普通方法之间需要调用的时候，可以使用this来进行调用，指的是当前对象的其他方法
③成员变量：当方法中的参数名称跟成员变量保持一致的时候，使用 this.变量名称 表示的是对象的值，而使用变量名称表示形参列表中的值。

（2）用途：

1）构造方法：访问一个类的成员变量，解决与局部变量名称冲突：
class Person{
	int age;		//成员变量
	public Person(int age){		//局部变量
		this.age = age;			//访问成员变量
	} 
	public int getAge(){
		return this.age;
	}
}
2）普通方法：调用成员方法：
class Person{
	public void openMouth(){
		...
	}
	public void speak(){
		this.openMouth();		//this可省略
	}
}
3）成员变量：调用其他构造方法：
    class Person{
        public Person(){
            System.out.println("无参的构造方法被调用");
        }
        public Person(String name){
            this();      					   //调用无参的构造方法
            System.out.println("有参的构造方法被调用");
        }
    }
    public class Example{
        public static void main(String[] args) {
            Person p = new Person("itcast");    //实例化Person对象
        }
    }

运行结果：

无参的构造方法被调用
有参的构造方法被调用

调用类的构造方法时注意：
①只能在构造方法中使用this调用其他的构造方法，不能再成员方法中使用。
②在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。

五、垃圾回收

  • 一个对象成为垃圾后会暂时不开启在内存中，当这样的垃圾堆积到一定程度时，Java虚拟机会启动垃圾回收器将这些垃圾对象从内存中释放，从而使程序获得更多的内存空间；
  • 可通过调用 System.gc() 实现；
  • 当一个对象在内存中被释放，它的 finalize() 方法被自动调用，可通过此方法看到对象何时被释放。

六、static关键字

（1）定义

-静态变量
  • 使用static关键字修饰的成员变量，称为静态变量。
  • 静态变量被所有实例共享。
  • static只能修饰成员变量，不能修饰局部变量。
-静态方法：
  • 在类中定义的方法前加上static关键字，称为静态方法。
  • 在一个静态方法中只能访问用static修饰的成员，因为没有被static修饰的成员需要先创建对象才能访问，而静态方法被调用时无需创建对象。
-静态代码块：
  • 用static关键字修饰的代码块，称为静态代码块。
  • 静态代码块只执行一次，随着类被加载时执行。
  • 通常用静态代码块对类的成员变量进行初始化。

注意：
①静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化；
②静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用；
③成员变量放在堆中，而静态变量放在方法区中静态区；
④静态变量不能定义在静态方法中；
⑤静态方法可以再非静态方法中调用；
⑥静态方法中不能直接调用非静态方法；
⑦静态方法中不允许出现this调用；
⑧一般工具类中的方法定义为static。

总的来说：可修饰方法和成员变量

五、代码块

（1）分类

  • 普通代码块：定义在方法中，使用{ }括起来的代码叫做普通代码块；
  • 构造代码块：定义在类中，使用{ }括起来的代码叫做构造代码块 ；
    注意：每次代码运行的时候会将构造代码块中的代码添加到构造方法的前面 构造代码块中的代码会添加到每一个构造方法中，当使用 this（参数）的时候不会添加；
  • 静态代码块：使用static{}括起来的代码叫做静态代码块，在程序载入的时候优先执行。
    属于类数据库连接等其他提前需要准备好的代码会放在static代码块
  • 同步代码块：在多线程的时候会使用，用来给共享空间进行加锁操作

执行顺序：静态代码块——构造代码块（创建对象的时候才会使用）——普通代码块

（2）静态初始化块

  • 如果希望加载后，能对整个类进行某些初始化操作，可以使用static初始化块；
  • 类第一次被载入时先执行static代码块；类多次载入时，static代码块只执行一次，static经常用来进行static变量的初始化；
  • 是在类初始化时执行，不是在创建对象时执行；
  • 静态初始化块中不能访问非static成员。

（3）pakage——对应到文件系统就是多级目录

1）why?为了解决两个问题：

类之间的重名问题
为了便于管理类：将具体处理功能的代码放到同一个目录下

2）How？如何使用：
  • 一般定义Package会放置在Java文件的第一行，第一句的非注释性语句
    Package 域名的倒写，再加上模块名，并与内部管理类
    例如：package com.mashibing.
  • 完全限定名：包名+类名
    注意：写项目时都要加包，不要使用默认包
    例如：Com.gao和com.gao.car，这两个包没有包含关系，是两个完全独立的包，只是逻辑上看起来后者是前者的一部分。
4）JDK中常用包

Lang：不需要手动导入，自动加载
Util：工具包
net：网络包
Io：输入输出流包

5）Import
  • Why？
    如果不使用Import，我们如果用到非lang的其他包的类时，只能这么写：java.tuil.Date，每次都需将类的完全限定名加上，代码量太大，不利于编写和维护。通过Import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用。
  • How？
    Import java.util.Date;
    Import java.util.*; //导入该包下所有的类，会降低编译速度，但不会降低运行速度

注意：java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用；
如果导入两个同名的类，只能用包类+类名来显示调用相关类；
Java.util.Date date=new java.util.Date();

六、内部类

  • 在一个类的内部定义一个类，这个类称为内部类。这个内部类所在的类称为外部类。

（1）成员内部类

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

（2）静态内部类

  • 使用static关键字修饰一个成员内部类，该内部类称为静态内部类。
  • 它可以再不创建外部类对象的情况下被实例化。
外部类名.内部类名 变量名 = new 外部类名.内部类名();
注意：

①在静态内部类中只能访问外部类的静态成员；
②在静态内部类中可以定义静态的成员，而在非静态内部类中不允许定义静态成员。

（3）方法内部类

  • 在成员方法中定义的类，只能在当前方法被使用，这个类称为方法内部类。

结尾

以上就是面向对象的一些基础知识了，欢迎提出宝贵意见或建议~

posted @ 2020-11-01 21:13  肥宅快乐鼠  阅读(42)  评论(0)  编辑  收藏  举报