java重难点知识梳理 之面向对象特点及基础

Posted 2021-05-26 小牛儿学JAVA

java重难点知识梳理

• • • 继承
    • 多态
    • 封装
    • 重写
    • 重载
    • 关键字
    • • static关键字
      • this关键字
      • super关键字
      • final关键字

继承

java主要的编程思想是面向对象，世间万物皆可看作一个对象，java语言中的Object对象即可代表万物，是所有类的父类或基类。举个例子：比如在自然界中有动物、植物和微生物等等，但是仅仅说动物你并不知道这类动物是哺乳动物还是非哺乳动物，接着说哺乳动物你有不知道哺乳动物具体的名字叫什么，最后知道这只动物是哺乳动物中的小狗，但是又好奇小狗的品种是什么…等等，就不往下划分了。从中我们可以看出类与类之间是有相互关系的，把这种关系可以看作是继承。被继承者叫父类，继承者叫子类。
继承的特点：

1. 父类描述比子类的描述更抽象，子类的描述更具体
2. 父类不能访问子类所独有的属性和方法，子类可以访问父类的所有方法和属性。前提是父类的属性和方法不是私有的！
3. 通常情况下继承只能是单一继承，父类可以有多个子类。子类只能有一个父类。
4. 在创建子类对象时，先调用父类的构造方法，在调用子类的构造方法。
5. 继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
   父类

package com.openlab.pojo;

public class Animal {
	
	public String name;
	public int legs;
	
	{
		System.out.println("xxx");
	}
	static{
		System.out.println("456");
	}
	
	public Animal(String name,int legs) {
		System.out.println("This is  an  Animal！！！");
	}
	
	
	//  动物开心了的表达方式
	public void enjoy(){
		
		System.out.println("叫两声");
	}

}

子类

package com.openlab.pojo;

public class Dog extends Animal {
	
	private static Dog d = new Dog("大黄",5);
	
	public String eyescolor;
	//  123 - Animal -Dog
	{
		System.out.println("000");
	}
	//静态代码块
	static{
		System.out.println("123");
	}
	
	public Dog(String name,int legs) {
		super(name, legs);
		System.out.println("This is  A DOG！！！");
	}
	public void eat(){
		System.out.println("干饭 ");
	}

}

多态

多态字面意思表示多种状态或多种表示形态，可以理解为父类引用指向子类对象，例如：

Animal dog = new Dog();

多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。
对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。
Java 实现多态有 3 个必要条件：继承、重写和向上转型。只有满足这 3 个条件，开发人员才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而执行不同的行为。
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。

封装

封装将类、方法和变量设置不同的访问范围

封装将类的某些信息隐藏在类内部，不允许外部程序直接访问，只能通过该类提供的方法来实现对隐藏信息的操作和访问。例如：一台计算机内部极其复杂，有主板、CPU、硬盘和内存， 而一般用户不需要了解它的内部细节，不需要知道主板的型号、CPU 主频、硬盘和内存的大小，于是计算机制造商将用机箱把计算机封装起来，对外提供了一些接口，如鼠标、键盘和显示器等，这样当用户使用计算机就非常方便。
封装的特点：
只能通过规定的方法访问数据。
隐藏类的实例细节，方便修改和实现。
实现封装的具体步骤如下：
修改属性的可见性来限制对属性的访问，一般设为 private。
为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。
在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）。

java中权限访问修饰符主要有

public  公共的      作用域：在整个工程下任意地方都可以访问
default  默认的     作用域：同包下可以访问
protected 受保护的  作用域：同包和子类下
private  私有的      作用域：只能本类中访问

class 只能使用 public  default  static  final  abstract
field 变量 ----public default static final protected private
method 方法  ---- public default static final protected private
constructor 构造器

重写

重写一般指的是重写父类的方法，大前提是两个类中一个继承一个被继承的关系。

在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候，需要方法重写。
子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强
在重写方法时，需要遵循下面的规则：
参数列表必须完全与被重写的方法参数列表相同。
返回的类型必须与被重写的方法的返回类型相同（Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）。
访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。
重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。
另外还要注意以下几条：
重写的方法可以使用 @Override 注解来标识。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够再次声明。
构造方法不能被重写。
子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。
如果不能继承一个方法，则不能重写这个方法。

重载

大前提在一个类里，定义相同的方法名且参数列表不同的方法称为重载。

Java 允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法，但形参列表不同，这种情况被称为方法重载（overload）。

关键字

面向对象有许多重要的关键字，例如extends继承，static静态，this当前对类的引用，super父类的引用

static关键字

注意：
1.被static关键字所修饰的属性和方法 被整个程序共享，通过类名直接调用
2.静态方法中不能访问非静态变量和方法
3.在非静态方法中不能声明静态的局部变量
4.被static修饰的属性 优先被加载 优先于主方法
5.静态代码块只执行一次 优先于代码块和构造方法
6.静态代码块和静态变量同时存在时 按照先后顺序执行

在类中，使用 static 修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量，常量称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。
静态成员不依赖于类的特定实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java 虚拟机就可以根据类名找到它们。
调用静态成员的语法形式如下：
类名.静态成员
注意：
static 修饰的成员变量和方法，从属于类。
普通变量和方法从属于对象。
静态方法不能调用非静态成员，编译会报错。
静态变量
类的成员变量可以分为以下两种：
静态变量（或称为类变量），指被 static 修饰的成员变量。
实例变量，指没有被 static 修饰的成员变量。
静态变量与实例变量的区别如下：
1）静态变量
运行时，Java 虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。
在类的内部，可以在任何方法内直接访问静态变量。
在其他类中，可以通过类名访问该类中的静态变量。
2）实例变量
每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。
在类的内部，可以在非静态方法中直接访问实例变量。
在本类的静态方法或其他类中则需要通过类的实例对象进行访问。
静态变量在类中的作用如下：
静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据，增加实例之间的交互性。
如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。例如，在类中定义一个静态常量 PI。

this关键字

This ------当前类的引用，this 关键字是 Java 常用的关键字，可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。
1.用于构造方法初始化对象
2. 用于调用无参构造方法
3. this可以当作返回值使用

	public Person(String name,int age) {
		
		this();
		this.name = name;
		this.age = age;
	}

	public Person getPersonInstance(){
		return this;
	}

super关键字

由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。
super 关键字的功能：
在子类的构造方法中显式的调用父类构造方法
访问父类的成员方法和变量

final关键字

final 在 Java 中的意思是最终，也可以称为完结器，表示对象是最终形态的，不可改变的意思。final 应用于类、方法和变量时意义是不同的，但本质是一样的，都表示不可改变，类似 C# 里的 sealed 关键字。
使用 final 关键字声明类、变量和方法需要注意以下几点：
final 用在变量的前面表示变量的值不可以改变，此时该变量可以被称为常量。
final 用在方法的前面表示方法不可以被重写（子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。这里了解即可，教程后面我们会详细讲解）。
final 用在类的前面表示该类不能有子类，即该类不可以被继承。
final 修饰变量
final 修饰的变量即成为常量，只能赋值一次，但是 final 所修饰局部变量和成员变量有所不同。
final 修饰的局部变量必须使用之前被赋值一次才能使用。
final 修饰的成员变量在声明时没有赋值的叫“空白 final 变量”。空白 final 变量必须在构造方法或静态代码块中初始化。
注意：final 修饰的变量不能被赋值这种说法是错误的，严格的说法是，final 修饰的变量不可被改变，一旦获得了初始值，该 final 变量的值就不能被重新赋值。