【JAVA总结】面向对象编程-类与对象(下)

 

1.代码块（考点）
代码块定义：使⽤ {} 定义的⼀段代码。

1.1 普通代码块
普通代码块：定义在⽅法中的代码块（直接使⽤{}定义，普通方法块）

1.2 构造块
构造块：定义在类中的代码块(不加修饰符)

class Person{     
    { //定义在类中，不加任何修饰符，构造块    
         System.out.println("1.Person类的构造块");   
    }     
    public Person(){       
      System.out.println("2.Person类的构造⽅法");
public class Test{  
    public static void main(String[] args) {    
        new Person();       
        new Person();  
    }
}

构造块优先于构造方法执⾏，每产生⼀个新的对象就调用⼀次构造块，构造块
可以进行简单的逻辑操作（在调用构造方法前）

1.3 静态代码块
静态代码块：使⽤static定义的代码块

根据静态块所在的类的不同⼜可分为以下两种类型
>1. 在⾮主类中
>2. 在主类中

***
小结：
>1. 静态块优先于构造块执⾏。
>2. ⽆论产⽣多少实例化对象，静态块都只执⾏⼀次。
>3. 静态块的主要作⽤是为static属性进⾏初始化
>4. 在主类中定义的静态块，优先于主⽅法（main）执⾏

2.内部类的定义与使用

2.1 内部类的基本概念
内部类：所谓内部类就是在⼀个类的内部进行其他类结构的嵌套的操作

public class Outer{

        class Inner{

        }

}

2.2 内部类为什么存在

>1. 内部类方法可以访问该类定义所在作⽤域中的数据，包括被 private 修饰的私有数据
>2. 内部类可以对同⼀包中的其他类隐藏起来
>3. 内部类可以实现 java 单继承的缺陷
>4. 当我们想要定义⼀个回调函数却不想写⼤量代码的时候我们可以选择使⽤匿名内部类来实现

2.3 内部类与外部类的关系

 - 对于非静态内部类，内部类的创建依赖外部类的实例对象，在没有外部类实例之前是无法创建内部类的
 - 内部类是⼀个相对独立的实体，与外部类不是is-a关系
 - 内部类可以直接访问外部类的元素(包含私有域)，但是外部类不可以直接访问内部类的元素
 - 外部类可以通过内部类引用间接访问内部类元素

2.4 内部类

2.4.1 内部类分类
在Java中内部类主要分为：

 实例内部类，静态内部类，本地内部类，匿名内部类

 

 

 

 

 

 

 

2.4.1 在使⽤内部类的时候创建内部类对象

外部类.内部类 内部类对象 = new 外部类().new 内部类();
Outter.Inner in = new Outter().new Inner();

2.4.2 在外部类内部创建内部类对象

在外部类内部创建内部类，就像普通对象⼀样直接创建
Inner in = new Inner();

2.5 内部类详解

2.5.1 实例内部类
在实例内部类中要注意两点：
>1. 实例内部类中不能存在任何static的变量和⽅法
>2. 实例内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类

package com.company;


  //外部类、成员内部类的定义

public class Outer {

    private int outerNum = 100;
    private int commonNum = 500;
    private static int outerStaticNum = 800;
    
     // 成员方法

    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法");
    }
    
     //静态方法

    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod静态方法");
    }
    
     // 内部类

    public class Inner {

        private int commonNum = 20;
        
         // 构造方法

        public Inner() {
        }

         // 成员方法，访问外部类信息（属性、方法）

        public void innerShow() {
            //当和外部类冲突时，直接引用属性名，是内部类的成员属性
            System.out.println("内部的commonNum:" + commonNum);
            //内部类访问外部属性
            System.out.println("outerNum:" + outerNum);
            //当和外部类属性名重叠时，可通过外部类名.this.属性名
            System.out.println("外部的commonNum:" + Outer.this.commonNum);
            //内部类访问外部静态类
            System.out.println("outerStaticNum:" + outerStaticNum);

            //访问外部类的方法
            outerMethod();
            outerStaticMethod();
        }
    }
    
     //	外部类访问内部类的信息

    public void outerShow() {
        Inner inner = new Inner(); //在外部类的实例上，创建内部类实例
        inner.innerShow(); //调用内部类
    }
}

2.5.2 静态内部类
关键字static可以修饰成员变量、⽅法、代码块，使⽤static修饰的内部类称之为静态内部类。静态内部类与⾮静态内部类之间存在⼀个最⼤的区别，我们知道⾮静态内部类在编译完成之后会隐含地保存着⼀个引⽤，该引⽤是指向创建它的外围类，但是静态内部类却没有。没有这个引⽤就意味着：
>1. 静态内部类的创建是不需要依赖于外围类，可以直接创建 
>2. 静态内部类不可以使⽤任何外围类的⾮static成员变量和⽅法，⽽内部类则都可以外部类的创建语法: ```外部类.内部类 内部类对象 = new 外部类.内部类(); ```

    
 2.5.3 方法内部类
   
方法内部类定义在外部类的方法中，局部内部类和成员内部类基本⼀致，只是它们的作用域不同，方法内部类只能在该方法中被使⽤，出了该方法就会失效。
>1. 局部内类不允许使⽤访问权限修饰符 public private protected 均不允许
>2. 局部内部类对外完全隐藏，除了创建这个类的⽅法可以访问它其他的地⽅是不允许访问的3. 局部内部类要想使⽤⽅法形参，该形参必须⽤final声明(JDK8形参变为隐式final声明).

2.5.4 匿名内部类
匿名内部类其实就是⼀个没有名字的⽅法内部类
注意事项：
>1. 匿名内部类是没有访问修饰符的。
>2. 匿名内部类必须继承⼀个抽象类或者实现⼀个接⼝
>3. 匿名内部类中不能存在任何静态成员或⽅法
>4. 匿名内部类是没有构造⽅法的，因为它没有类名。
>5. 与局部内部相同匿名内部类也可以引⽤⽅法形参。此形参也必须声明为 final

3.继承的定义与使用
⾯向对象的第二大特征：继承。继承的主要作用在于，在已有基础上继续进行功能的扩充。

3.1 继承的实现
继承的主要作用是对类进行扩充以及代码的重用。
 

class ⼦类 extends ⽗类

subClass extends superClass{
}
	subClass 子类，也叫派生类
	superClass 父类，也叫基类、超类

 

关于继承定义的说明：
>⼦类在⼀些书上也被称为派⽣类，⽗类也被称为超类(Super Class)
***
*说明：派生类需要帮助基类去构造，调用基类的构造函数（利用supper关键字）
调用父类的构造函数（放第一行）。

3.2 继承的限制
子类对象在进行实例化前⼀定会⾸先实例化父类对象。默认调用父类的构造方法后再调用子类构造⽅法进行子类对象初始化。
>Java只允许单继承，不允许多继承。
⼀个⼦类只能继承⼀个⽗类。

4.覆写（override）

如果子类定义了与父类相同的方法或属性的时候，这样的操作就称为覆写（override）
建议： 1.以后写方法时，99.99%的情况下建议使用public。2.写属性，98%情况下建议使用private。

 

	重载（overload）	覆写（override）
概念	方法名称相同，参数的类型及个数不同	方法名称、返回值类型、参数的类型及个数完全相同
范围	一个类	继承关系
限制	无	被覆写的方法不能有比父类更严格的防蚊控制权限

 

4.3 super关键字

上⾯讲到⼦类对象实例化操作的时候讲过super()，当时的主要作⽤是⼦类调⽤⽗类构造⽅法时才使⽤
的。
那么在进⾏覆写的操作过程之中，⼦类也可以使⽤super.⽅法()/super.属性明确调⽤⽗类中的⽅法或属性

 

区别	this	supper
概念	访问本类中的属性和方法	由子类访问父类中的属性、方法
查找范围	先查找本类，如果本类没有就调用父类	不查找本类，直接调用父类定义
特殊	表示当前对象	无

5.final关键字

• 使⽤final修饰类、⽅法、属性
• final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误
• 使⽤final定义的类不能有⼦类(String类便是使⽤final定义)
• final⼀旦修饰⼀个类之后，该类的所有⽅法默认都会加上final修饰。(不包含成员变量)
• 使⽤final定义的⽅法不能被⼦类所覆写
• 使⽤final定义的变量就成为了常量常量必须在声明时赋值并且不能够被修改
• 使⽤final修饰的变量不能再次赋值
• 定义常量(public static final )，常量全⽤⼤写字⺟，多个单词间以_分隔。

 

6.多态性

 

6.1 多态表现
在Java中，对于多态的核⼼表现主要有以下两点：

1⽅法的多态性：
①⽅法的重载：同⼀个⽅法名称可以根据参数的类型或个数不同调⽤不同的⽅法体
②⽅法的覆写：同⼀个⽗类的⽅法，可能根据实例化⼦类的不同也有不同的实现。

2对象的多态性【抽象类和接⼝才能体会到实际⽤处】（前提：⽅法覆写）：
【⾃动，90%】①对象的向上转型：⽗类 ⽗类对象 = ⼦类实例。
【强制， 1%】②对象的向下转型：⼦类 ⼦类对象 =（⼦类）⽗类实例。