欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

Java面向对象（萌新的学习心得及笔记）

程序员文章站 2022-07-10 18:43:55
JAVA面向对象本人也是一个才学习Java不久的萌新，有很多的东西还需要我继续去学习去理解，由于目前接触也不是很多，所以如果有任何不足的地方，请大家谅解，也希望大家能继续补充或者提出见解。什么是对象？对象就是具有某些的特殊属性（成员变量）和行为方式（方法）的实体。现实生活中的任何事物都可以理解为是 一个对象，无论是具体或抽象的事物，Java中就有了一种思想叫做“万物皆对象”。属性是先人根据可描述实物抽象出来的。行为是这个抽线实物可以具体实现的功能。举例说明：我是一个人，我可以跑步。人（...

JAVA面向对象

本人也是一个才学习Java不久的萌新，有很多的东西还需要我继续去学习去理解，由于目前接触也不是很多，所以如果有任何不足的地方，请大家谅解，也希望大家能继续补充或者提出见解。

什么是对象？

  • 对象就是具有某些的特殊属性（成员变量）和行为方式（方法）的实体。
  • 现实生活中的任何事物都可以理解为是 一个对象，无论是具体或抽象的事物，Java中就有了一种思想叫做“万物皆对象”。
  • 属性是先人根据可描述实物抽象出来的。
    行为是这个抽线实物可以具体实现的功能。

举例说明：

我是一个人，我可以跑步。
人（属性，Property） 人就是给我定义的属性。
跑步（具体行为，Behavior）跑步就是给我定义的一个行为。

什么是面向对象？

  • 了解面向对象之前需要我们知道什么是面向过程，面向过程是以函数为基础，完成各种操作，强调过程；就是分析出解决问题所需要的步骤，然后用函数把这些步骤一个一个串联起来，一步一步实现，使用的时候一个一个依次调用。
  • 面向对象是以对象为基础，完成各种操作，主要强调对象、结果。是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
  • 面向对象的编程语言，是将功能封装进对象，强调具备某些功能的对象，其实面向对象的语言是基于面向过程的，因为即使是调用某个对象，被调用的对象的方法也是通过面向过程的方式编写的。但面向对象的编程思想更加符合人们的日常思维，将复杂的问题分解为不同领域的简单问题，一步一步拆开，更便于逻辑分析与分工合作。

面向对象学习内容

  1. 面向对象和面向过程
  2. 类和对象
  3. 对象的行为
  4. 对象数组
  5. 引用的对象
  6. 类的高级概念
  7. 继承
  8. 多态
  9. 抽象
  10. 接口
  11. OOAD面向对象分析设计

面向对象和面向过程

  • 面向过程，是一种置顶向下，逐步求精的思想，需要关注每一个细节。

  • 面向对象，通过面向职责进行问题域的划分，每个职责只关注该职责应该完成的任务，从而可以忽略一些细节。

  • 如何理解面向过程和面向对象：面向对象是一种分析问题的方式，在开发中，先用面向对象思想进行职责和问题域的划分，然后，实现时，利用面向过程实现具体的操作。

  • 什么是对象：

     1、对象是存在的具体实体，具有明确定义的特征和行为。
 2、万物皆对象，对象因我关注而产生。
 3、面向对象：一种认识事物的方式，注重对事物整体的认知。

  • 面向对象的术语：

     1、OO：面向对象
 2、OOP：面向对象编程
 3、OOA：面向对象分析
 4、OOD：面向对象设计

  • 面向对象的特征：

     1、继承
 2、封装
 3、多态

  • 对象
    this表示当前对象，在方法中使用this，表示访问该对象的属性或者方法。

类和对象

类是对象的抽象，对象是类的实例。

  • 什么是类

     1、类是具有相同属性和行为的一组对象的集合。
 2、在软件系统中，我们用类来模拟现实生活中的实体。

  • this的用法

     1、this表示当前对象，在方法中使用this.（）表示当前访问的属性或方法。
 2、在方法中，直接访问变量，优先访问局部变量，如果要访问属性，需要加上this.（）

  • 类与类的关系

     1、has-a
 一个类是另一个类的属性，是整体和部分的关系，是一种聚合/组合的关系。
 2、use-a
 一个类是另一个类方法的参数、返回类型、局部变量，是一种使用的关系。

  • 属性
    1、普通属性

     (1)创建对象时，每个属性都会做初始化，int---0，double---0.0，引用类型---null。
 (2)不同的对象属性彼此独立，改变一个对象的属性值，不会影响别的对象。

    2、静态属性（加static）

     (1)唯一性，所有对象共享一个静态变量。
 (2)静态变量一改变，影响所有对象 。
 (3)静态变量在类加载时产生，产生在对象之前，并完成初始化，int---0  double---0.0 引用类型---null
 (4)静态变量可以用对象.和类名.的方式访问，所以，静态变量也称为类的变量

    3、静态变量和成员变量的区别

     (1)成员变量（属性）包含在对象之中，不同的对象成员变量彼此独立，改变一个对象的属性值不会影响别的对象。静态变量独立在对象之外，多个对象共享一个 静态变量，静态变量改变后会影响所有对象。
 (2)静态变量在类加载时产生，产生在对象之前，长驻内存。
 (3)静态变量可以通过对象和类去访问，但成员变量只能通过对象访问。

    4、静态方法可以直接访问静态方法或静态变量，但是不能直接访问成员方法或成员变量。也不能用this。

对象的行为

在方法中，传递和返回对象，传递和返回的是对象的引用,且在Java中，只有值传递。

  • 方法调用栈
    当调用方法时，会使该方法位于调用栈的顶部，当方法执行完毕后，从调用栈顶部移除。

  • 方法的重载
    方法重载发生在同一个类中，两个方法的方法名相同，参数列表不同（类型、顺序、个数）。调用方法是根据实参来决定调用执行哪个重载方法。
    1、编译时，方法名和方法参数的类型会参与编译。
    2、重载和方法的返回类型、方法形参名无关的。
    3、在调用方法时，如果一个实参同时匹配多个重载方法的形参，优先调用形参类型更小的重载方法。（double、long、short、int）

  • 方法的分类
    1、成员方法
    成员方法的调用必须通过对象.的方式调用。
    2、静态方法（在方法定义时加上static）

     （1）静态方法在类加载时产生，加载在对象之前。所以，在静态方法中不能直接调用成员变量和成员方法，也不能用this。
 （2）对静态方法的调用，可以通过对象.和类名.的方式调用。
 （3）静态变量和静态方法的产生都不需要依赖于对象。所以，当null值调用静态变量和静态方法时，可以正常执行，不会抛出空指针异常。

    3、构造方法

     （1）构造方法的方法名和类名相同，没有返回类型，主要用于对象的创建。
 （2）如果一个类中没有定义构造方法，那么编译器会自动分配一个无参构造方法。如果一个类定义了构造方法，那么编译器不会再分配无参构造方法。
 （3）作用：为对象分配空间、初始化成员变量、返回对象的引用
 （4）this();表示在一个构造方法中，调用当先类中的另一个构造方法。且this();只能放在第一句

对象数组

  1. 对象数组中的元素都是引用数据类型，创建后，初始值为null

  2. 只有让数组元素引用对象，才能对该元素进行属性和方法的调用，否则抛出空指针异常

  3. 复制数组可以使用System.arrayCopy()

  4. 产生帮助文档用javadoc命令，可以将文档注释写入API文档。

  5. 定义：

    int[] x = new int[3];创建长度为3的数组，初始值为0
int[] x = {2,3,4};以初始化元素的个数，作为数组长度，只能在定义的时候使用，引用新数组，或传实参都不能用。
int[] x = new int[]{2,3,4,5};以初始化元素的个数，做为数组长度，在定义，引用新数组，传实参都可以使用。

  6. 可变长数组：
    可变长数组的定义，只能用于方法的形参。

    例：public void test(int...array){}
调用：test(3,4,5,6,7);
test（new int[]{2,3,4,5,6}）；

    可变长数组参数，只能是方法的最后一个形参。

类的高级概念

  1. 访问修饰符：

    （1）定义：类的每一个成员都有一个访问的权限。访问修饰符决定了类的成员是否能被别的类所访问。
（2）分类：
	*public*：公有的，本类和非本类都可以访问。
	*protected*：受保护的，同包和不同包的子类可以访问。（用protected修饰构造方法，不表示该构造方法能被子类继承  ，而	是指不同包的子类可以调用构造方法，产生父类对象。）
	*默认*：本包可以访问。
	*private*：私有的，本类可以访问。
（3）在一个包中有一个Student类，有一个Test测试类。在Test类中，是否能访问Student从Object中继承的protected修饰符的finalize方法

  2. 初始化块：

    （1）静态初始化块：

    1、静态初始化块，只在类加载时执行一次，不会因为对象的产生而执行。
2、一个类可以定义多个静态初始化块，类加载时按书写顺序执行。
在静态初始化块中，不能直接访问成员变量和成员方法。也不能用this

    3、访问静态变量：

    如果静态变量定义在静态初始化块之前，可以直接访问。
如果静态变量定义在静态初始化块之后，需要用类名.的方式访问。

    4、语法：

    class A{
static{
}
}

    （2）实例初始化块：

    1、实例初始化块依赖于对象，没产生一个对象，就执行一次实例初始化块，在spuer()后执行。
2、访问成员变量：
	如果成员变量定义在实例初始化块之前 ，可以直接访问。
	如果成员变量定义在实例初始化块之后，需要用this.的方式访问。

    1. 内部类：
      1、在一个类中，再建一个类，这个类称为内部类。
      2、按存在位置分：
      （1）成员内部类：

      语法：
class Dog{
	public class X{
			public X(){
				System.out.println("Dog中的X类，产生对象");
			}
	}
}
Dog d = new Dog();
Dog.X a = d.new X();

      1、成员内部类相当于外部类的属性，成员内部类对象的产生，需要依赖于外部类的 对象。
      2、成员内部类也有独立的class文件，命名规则为：外部类名$内部类名.class
      3、在内部类中，访问外部类对象：外部类类名.this
      4、静态内部类：静态内部类是成员内部类的特例。静态内部类对象的产生不需要依赖于外部类对象。语法：

      class Dog{
	public  static class Y{

	}
}
Dog.Y  b = new Dog.Y();

      （2）局部内部类
      局部内部类是在类的方法内部定义的类。局部内部类只能在定义的方法内部中使用，一旦方法执行完毕，局部内部就会从内存中自动移除。语法：

      public static void main(String[] args){
		class MyTest{
				private int x;
}
		MyTest  m = new MyTest();
		m.x = 8;
	}
}

      （3）匿名内部类
      匿名内部类是局部内部类的特例，该类将类的定义和对象的创建结合在一起，只能为一个对象服务。语法：

      MM m1 = new MM() {
	@Override
	public void move() {

	}
};

封装

  • 按照信息隐藏的原则，将数据组织在一起的形式，称之为封装。

  • 特点

     	1、信息的集合
 	2、信息的隐藏

  • 私有属性+get/set方法和公有属性的区别

     1、私有属性+get/set方法，由于私有属性无法直接访问，所以，可以通过删除get或set方法，将属性做成只读或只写属性，这一点公有属性做不到。
 2、私有属性，通过 set方法进行属性值设置时，可以进行属性值合法性的验证，可以避免非法数据的录入，这一点公有属性做不到。
 3、基于以上两点，属性如果没有特殊要求，一般都是私有的。

  • 标准javaBean的规范
    需要提供公有的无参构造方法
    私有属性+get/set方法，进行访问和修改
    实现序列化接口

继承

  1. 子类继承父类以后，可以重用父类中定义的属性和方法，采用extends关键字

  2. 子类可以在父类基础上，扩展自己特有的属性和方法

  3. 继承可以看作是类的抽象，将几个类中相同的属性和行为抽取到父类中，子类通过继承重用代码

  4. 继承是一种is-a的关系，用”是“来判断两个类之间是否有继承关系。比如：狗是动物，那么狗 继承于动物这个类。

  5. 继承使用原则

    （1）观察要使用的类，讲共同的属性和方法迁移到父类，便于代码重用。
（2）对于不同的属性和方法在子类中重新定义。
（3）在设计阶段，现有子类，通过多个子类的抽象，定义父类。
（4）开发阶段，先定义父类，再通过子类继承父类，重用代码。

  6. 单根继承和多继承
    （1）单根继承：

    优点：类继承的层次结构非常清晰，设计上更容易把握父类具有唯一共性。
缺点：设计丰富度会降低。

    （2）多继承：

    优点：可以同时具有多个父类的特征，让子类有更大的丰富度。
缺点：如果多个父类有相同的特征，那么子类继承哪一个？多继承会带来设计的混乱，继承结构也变得复杂。

    （3）在java中，一个类只能有一个父类，一个类不能同时继承两个父类。
    （4）所有的类都是直接或间接继承Object（java语言里的父类）

  7. 继承原理
    1、子类创建时，必须通过super()构造方法产生父类对象，如果子类构造方法没有写super()，那么编译器会自动加上super()。
    2、子类对象创建时，会先产生父类对象，然后在父类对象基础上扩展子类特有的属性和方法，所以，在子类对象中，会包含一个完整的父类对象，因此子类对象可以重用父类定义的属性和方法。
    3、如果父类中没有提供无参构造方法，那么，子类构造方法必须用super(实参)显示调用。
    4、注意：

    super()和this()是互相冲突的。
super()必须写在子类构造方法的第一句。

  8. 重写
    1、重写发生在父类和子类之间，子类方法名和父类相同，参数列表相同，返回类型相同，调用方法时，优先调用子类重写的方法，如果子类没有重写父类方法，那么就调用父类中继承的方法。
    2、在子类方法上，可以加上@Override关键字。强行检测子类方法是否重写了父类方法，如果子类方法没有重写到父类方法，则编译错误。
    3、重写的限制：

    	（1）子类方法的访问修饰符要大于或等于父类方法
	（2）子类方法抛出的异常要小于或等于父类方法

    4、子类重写了父类的方法，父类的方法没有消失，可以用super().的方式访问父类中定义的属性或方法。
    5、注意：private和static、final、构造方法不能被子类重写。
    6、构造方法不能被子类继承，同样，构造方法也被能被子类重写。
    （1）构造方法申明为protected，不表示该构造方法能被子类继承，指的是不同包的子类可以调用该构造方法产生父类对象。
    （2）在别的类中产生对象，同时也不能有子类。如果一个类构造方法是private私有的，表示该类不能在彼得类中产生对象，同时也不能有子类。

  9. final的用法

    1、final修饰符，表示该类不能被继承。
2、final修饰方法，表示该方法不能被子类重写。
3、final修饰变量 ，表示变量的内容不能改变。
4、final修饰基本数据类型变量，表示变量的值不能改变。final修饰引用数据类型的变量，表示该变量不能引用别的对象，也不能重新赋值为null。

多态

  1. 允许使用父类变量引用子类对象，允许使用接口变量引用实现类对象。但反过来却不行。

  2. 多态调用时，父类变量引用子类对象，只能调用父类中定义的属性和方法，不能调用子类特有的属性和方法。

  3. 多态调用时，父类变量引用子类对象，调用方法时，优先调用子类重写的方法。这样，同一个父类变量在引用不同子类对象时，调用的方法实现可能也不一样，这就是相同的行为，不同的实现方式。

  4. 多态的应用：
    （1）多态参数：如果使用父类变量为方法参数，意味着可以传递任何子类对象。如果使用接口变量做为方法参数，意味着可以传递任何一个实现类对象。
    （2）多态集合：以父类类型创建集合，集合中的每个元素可以引用任何一个子类对象。

  5. 多态的分类：
    （1）重载：在编译时就能确定调用哪个方法，称之为静态多态。
    （2）重写：在运行时，根据变量引用的具体对象，才能确定调用哪个方法，称之为动态多态。（动态绑定）

  6. instanceof：判断一变量引用的对象是否匹配某种类型，如果该变量为null，匹配任何类型都为false。语法：

    Animal a = new Bird();
//如果a的值为null空 都不匹配。

Animal a = null;
//判断一个变量引用的对象是否匹配某种类型,只要是a的父类都能匹配。

System.out.println(a instanceof Bird);
System.out.println(a instanceof Animal);
System.out.println(a instanceof Object);

  7. 转型：
    （1）向上转型：子类的变量可以直接赋值给父类变量（自动类型转换）。
    （2）向下转型：父类的变量要赋值给子类的变量就需要强制类型转换，向下转型有类型转换异常（java.lang.ClassCastException）的风险，所以向下转型之前，最好用instanceof判断一下变量引用的对象是否匹配该类型。

抽象

  1. 抽象方法：

    （1）如果一个方法只有定义没有内容，那么该方法就是抽象方法，用abstract修饰。
（2）抽象方法只能定义，不能有具体的内容，所以，抽象方法只能（；）分号，不能写{}，只要一些{}无论是否有内容，都是具体方法。
（3）抽象方法需要被子类重写，所以，不能用private、static、final去修饰。
（4）由于构造方法不能被重写，所以，不能用abstract修饰
（5）抽象方法的意义：1、规范子类的代码 1、可以实现多态调用

  2. 抽象类：

    （1）用abstract修饰的类，称为抽象类。
（2）抽象类不能直接实例化，抽象类变量只能引用子类对象。
（3）如果一个类继承一个抽象类，必须重写抽象类中定义的所有抽象方法，否则这个类只能是抽象类
（4）抽象类中可以定义抽象方法，也可以定义具体方法，同时抽象类当中也可以不定义抽象方法。
（5）如果一个类中有一个抽象方法，那么这个类只能是抽象类。

接口

  1. 接口可以看做是抽象类的特例，抽象类是属性和行为的抽象，两接口只是行为的抽象。

  2. 定义接口采用interface关键字，和抽象类一样，接口不能直接实例化。接口变量只能引用实现类对象。

  3. 一个类实现一个接口采用implements关键字，该类必须实现接口中定义的所有抽象方法，否则这个类就是抽象类。

  4. 接口中定义的方法，默认是public abstract，其中public abstract可以省去，不能用private 和protected修饰接口方法。

  5. 一个类只能继承一个父类，但是可以实现多个接口，中间可以逗号分开。

    interface A{
	public void a();
}

interface B{
	public void b();
}

class Man{}

class Hashband extends Man implements a,b{
		@Override
		public void a();
		@Override
		public void b();
}

  6. 接口可以继承接口，并可以多继承接口，一个类实现一个接口，除了实现该接口中定义的抽象方法以外，还要实现该接口父类接口中定义的抽象方法。

  7. 接口中定义的属性，都是public static final 。其中public static fanal可以省去。属性必须是常量且不能更改。

  8. 接口中可以定义具体方法(JDK1.8以后)，但是只能是default方法和静态方法。

    interface IWash{
	public void wash();
	public default void washCloth() {
		this.wash();
	}
	public static void test() {
	
	}
}

  9. 抽象类和接口的区别
    （1）共同点：

    1、抽象类和接口都不能直接实例化，抽象类变量只能引用子类对象，接口变量只能引用实现类对象
2、一个类继承一个抽象类，必须重写抽象类中定义的所有抽象方法，否则，这个类只能是抽象类，一个类实现接口，必须实现接口中定义的所有抽象方法，否则，这个类也只能是抽象类。

    （2）不同点：

    1、抽象类中有构造方法，但是接口中没有构造方法。
2、一个类只能继承一个抽象类，但是可以实现多个接口。同时接口	也可以多继承接口。
3、属性区别：抽象类中，变量、常量、静态、非静态属性，都可以定义 ，访问修饰符也可以是任意修饰符。但是，接口中的属性，只能是公共的静态的常量。
4、方法区别：抽象类中，静态、非静态、抽象、实现方法，都可以定义，访问修饰符也可以是任意修饰符。接口中，只能定义公有抽象方法，default方法(JDK1.8)、抽象方法。

OOAD面向对象分析设计

类和类的关系
	实现：一个类实现一个接口， is-like-a
	泛化：一个类继承另一个类，is-a
	依赖：一个类是另一个类方法的参数，返回类型，局部变量，use-a
	聚合：一个类是另一个类的属性，是整体和部分的关系，has-a
	组合：一个类是另一个类的不可分割的一部分，是一个强聚合，has-a
	依赖、聚合、组合、合称为关联

总结

此次的博客仅仅是我个人对面向对象的理解和自己的随堂笔记，如果大家还有什么补充的知识点的话请在留言栏留言。每一条信息我都会看，并且在看到之后都会回复。码字不易，希望能给你们带来帮助。

本文地址：https://blog.csdn.net/m0_51912596/article/details/109268409

相关标签： Java 编程语言

上一篇： Java容器介绍HashSet

下一篇： Java Filter过滤器（拦截路径和方式的配置+生命周期+多个过滤器的先后执行顺序）

推荐阅读