JAVA 基础学习之面向对象 (2)

最新推荐文章于 2023-02-13 19:57:07 发布

构建

最新推荐文章于 2023-02-13 19:57:07 发布

阅读量315

点赞数

分类专栏： java 基础

本文链接：https://blog.csdn.net/weixin_44560342/article/details/102909071

版权

java 基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

面向对象进阶

1、概述：

本章的重点主要是面向对象的三大特征：继承、封装、多态。另外还包括抽象类、接口、内部类等概念。

2、继承

2.1、好处：

继承让我们更加容易实现类的扩展。比如，我们定义了人类，再定义Boy类就只需要扩展人类即可。实现了代码的重用，不用再重新发明轮子。extends 扩展的意思

2.2、instanceof 运算符

instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false。

格式：

if(对象 instanceof 类){     执行的代码.... }

2.3、继承使用要点

1、父类也称作超类、基类、派生类等等。

2、java中类没有多继承，只有单继承。

3、子类继承父类后，可以得到父类的全部属性和方法（除了父类的构造方法），但不可以直接访问父类的私有成员（属性和方法）。

4、如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object（默认）。

（如果定义一个类时，没有写继承别的父类时，则它的父类默认就是object类。）

2.4、方法的重写

子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

2.4.1、方法的重写需要符合下面的三个要点：（要求）

“==” ：方法名和形参列表相同。
“≤” : 返回值类型和声明异常类型，子类小于或等于父类。
“≥” : 访问权限，子类要大于或等于父类。（访问权限private为时？？？）

2.5、继承的优点和缺点

优点：

1 提高了代码的复用性

2 提高了代码的维护性

3 建立了类与类之间的关系，继承是多态的前提。

继承的一个弊端：

1、打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。这时如何解决问题呢？介绍一个关键字， final : 最终。

2、在一定的程度上提高了类与类之间的耦合度

总结：继承可以更容易的实现类的扩展，java中类只有单继承。方法的重写实现多态的必要性条件，方法重写的前提是继承，记住方法重写的三要点

3、object 类基本特性

Object类是所有Java类的根基类，也就意味着所有的Java对象都拥有Object类的属性和方法。如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类。

3.1、tongString 方法

Object类中定义有public String toString()方法，其返回值是 String 类型

3.2、==和equals方法

方法	功能
==	代表比较双方是否相同，如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象
equals	Object 的 equals 方法默认就是比较两个对象的hashcode

4、super 关键字

super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。

4.1、继承树追溯

·属性/方法查找顺序：(比如：查找变量h)

  1. 查找当前类中有没有属性h

  2. 依次上溯每个父类，查看每个父类中是否有h，直到Object

  3. 如果没找到，则出现编译错误。

  4. 上面步骤，只要找到h变量，则这个过程终止。

5、封装

5.1、概述

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

5.2、优点

1、提高代码的安全性。

2、提高代码的复用性。

3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。

4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

5.3、修饰符

Java是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。 Java中4种“访问控制符”分别为private、default、protected、public，它们说明了面向对象的封装性，所以我们要利用它们尽可能的让访问权限降到最低，从而提高安全性。

private 表示私有，只有自己类能访问。
default 表示没有修饰符（默认），只用同一个包中的类能访问。
protected 表示可以被同一个包的类以及其它包的子类访问。
public 表示可以被该项目的所有包中的所有类访问

5.4、使用细节

一般使用private访问权限。
提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作(注意：boolean变量的get方法是is开头!)。
一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

总结：封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

6、多态

6.1、含义：

多态是同一个行为具有多个不同表现形式或形态的能力。

6.2、要点：

      1. 多态是方法的多态，不是属性的多态(多态与属性无关)。

  2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

  3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

printer p=new 彩色打印机(); 
printer p=new 黑白打印机();

6.3、优缺点

多态的主要优势：是提高了代码的可扩展性，符合开闭原则。

多态的弊端：就是无法调用子类特有的功能。

6.4、对象转型

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型!

7、final 关键字

7.1、作用

被 final 修饰的类是一个最终类，不可以被继承。
被 final 修饰的方法是一个最终方法，不可以被覆盖（重写）。
被 final 修饰的变量是一个常量，只能赋值一次。

8、抽象方法和抽象类

8.1、抽象方法

被abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

8.2、抽象类

被abstract修饰的类就是抽象类，通过abstract方法定义规范，然后要求子类必须定义具体实现。可以把抽象类看成一个模板，需要子类去实现。

/*抽象类*/
abstract class abstr{
//抽象方法abstract void show();
}

8.2.1、要点

1、抽象类不能实例化，即不能用new来实例化抽象类。

2、抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。

3、抽象类只能用来被继承。

4、抽象方法必须被子类实现。

总结：抽象方法没有方法体，只有声明；抽象类不能被实例化（不能代表没有构造函数）。抽象类只能用来被继承。

抽象方法必须被子类实现。

9、接口（interface）

9.1、概述：

java中的接口是类的蓝图。它有静态常量和抽象方法。java中的接口是一种实现抽象的机制。接口中只有抽象方法。接口用于在Java中实现抽象和多重继承。Java接口也表示IS-A关系。它不能像抽象类一样被实例化。从接口的实现者角度看，接口定义了可以向外部提供的服务。从接口的调用者角度看，接口定义了实现者能提供那些服务。接口和实现类不是父子关系，是实现规则的关系。

9.2、声明格式：

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {常量定义；  方法定义；}

定义接口的详细说明：

访问修饰符：只能是public或默认（default）。
接口名：和类名采用相同命名机制。
extends：接口可以多继承。
常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
方法：接口中的方法只能是：public abstract。省略的话，也是public abstract。

9.3、要点

普通类可以通过implement来实现接口中的规范。
接口不能创建实例，但是可用于声明引用变量类型。
JDK1.7之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。
JDK1.8后，接口中包含普通的静态方法。
一个类实现了接口，必须实现接口中所有的抽象方法。

示例：

public class Test21 {
    public static void main(String[] args) throws Exception {
    	Test impl=new TestImpl();
    	impl.show();//调用实现方法
    	Test.statics();//调用静态方法
	}
}
interface Test{
	abstract void show();//抽象方法
	 static void statics() {//静态方法
		System.out.println("我是静态方法");
	 };
}
class TestImpl implements Test {
	@Override
	public void show() {
		System.out.println("我是实现方法");
	}
}

结果：

10、内部类

10.1、概念：

有些情况下，我们把一个类放在另一个类的内部定义，称为内部类(innerclasses)。

内部类可以使用public、default、protected 、private以及static修饰。而外部顶级类(我们以前接触的类)只能使用public和default修饰。

public class Testnb {
	private int age=10;
	String name;
	public class Testnbl{
		//内部类中可以声明与外部类同名的属性与方法
        private int age = 20;
	}  
}

10.2、作用

内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能直接访问内部类的内部属性。（外部类如果需要访问内部类的属性，必须创建对象）
接口只是解决了多重继承的部分问题，而内部类使得多重继承的解决方案变得更加完整。

10.3、内部类的分类

在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类。

成员内部类(可以使用private、default、protected、public任意进行修饰。 类文件：外部类$内部类.class)

a、非静态内部类

非静态内部类必须寄存在一个外部类对象里，因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问内部类的成员。
非静态内部类不能有静态方法、静态属性和静态初始化块。
外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。
访问要点：局部变量：变量名；内部类属性：this.变量名；外部类属性：外部类名.this.变量名。
访问格式：

1. 外部类中定义内部类：

new inner（）

2.外部类以外的地方使用非静态内部类：

Outer.Inner varname = new Outer().new Inner()。

b、静态内部类

定义方式

static class ClassName {//类体}

为什么静态内部类的实例方法不能直接访问外部类的实例方法？

静态内部类是外部类的类相关的，而不是外部类的对象相关的。也就是说，静态内部类对象不是寄生在外部类的实例中，而是寄生在外部类的类本身中。

静态内部类看做外部类的一个静态成员。因此，外部类的方法中可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过 new 静态内部类()访问静态内部类的实例

c、匿名内部类

适合那种只需要使用一次的类。比如：键盘监听操作等等。

语法：

new 父类构造器(实参类表) \实现接口 () { //匿名内部类类体！}

注意：

1. 匿名内部类没有访问修饰符。

2. 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

d、局部内部类

它是定义在方法内部的，作用域只限于本方法，称为局部内部类。

格式：

public class Test2 {
    public void show() {
        //作用域仅限于该方法
        class Inner {
            public void fun() {
                System.out.println("helloworld");
            }
        }
        new Inner().fun();
    }
    public static void main(String[] args) {
        new Test2().show();
    }
}

总结：内部类主要分为成员内部类（非静态内部类、静态内部类）、匿名内部类、局部内部类。