狂神Java SE （七）面向对象

本文主要是介绍狂神Java SE （七）面向对象，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

01 什么是面向对象

面向对象与面向过程
- 面向过程思想
  - 步骤简单清晰，分步骤一步一步完成
  - 适合处理一些简单问题
- 面向对象思想
  - 物以类聚，分类的思维模式，考虑问题时，首先考虑解决问题需要哪些分类，然后对分类进行单独思考，最后对某个分类下的细节进行面向过程的思索
  - 适合处理发杂问题、需要多人协作的问题
- 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，需要使用面向对象的思路分析整个系统。具体到微观操作，仍然需要面向过程的思路去处理。
面向对象编程（Object-Oriented Programming，OOP ）
- 本质：以类的方式组织代码，以对象的形式组织（封装）数据
- 核心思想：抽象
- 三大特性：
  - 封装
  - 继承
  - 多态
- 从认识论角度考虑时现有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
- 从代码运行角度考虑是先有类后有对象。类是对象的模板

02 回顾方法的定义

修饰符
返回类型
break和return的区别
- break 跳出switch语句、结束循环
- return 结束方法，返回一个结果
方法名
参数列表（参数类型，参数名） ...
异常抛出

03 回顾方法的调用

静态方法 static
- 静态方法和类一起加载
- 静态方法中无法调用非静态方法
非静态方法
- 非静态方法在类实例化之后才存在
形参和实参
- 实参和形参的类型要对应

值传递和引用传递

package com.kuang.oop.demo01;

/**
 * 值传递与引用传递
 *
 * @author maple_w
 * Created on 21/07/12 012 15:08
 */
public class Demo01 {
	public static void main(String[] args) {
		int a = 1;
		System.out.println(a); // 1

		Demo01.change(a);
		System.out.println(a); // 1

		Person person = new Person();
		System.out.println(person.name); // null

		Demo01.change(person);
		System.out.println(person.name); // name

	}

	// 值传递
	public static void change(int a) {
		a = 10;
	}

	// 引用传递，但本质上还是值传递
	// 这里的person是一个对象，指向的是new出来的person，可以改变其属性
	public static void change(Person person) {
		person.name = "name";
	}
}

class Person {
	String name;
}

this关键字

04 类与对象的创建

类与对象的关系：

类是一种抽象的数据类型，是对某一类事物整体描述/定义，但不能代表某一个具体的事物
- 动物、植物、手机、电脑...
- Person类、Pet类、Car类等，都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
- 如张三是人的一个具体实例
- 能够体现出特点、展现出功能的是具体的实例，而不是也给抽象的概念。

初始化与创建对象：

使用new关键字创建对象
- 此时除了分配内存空间之外，还会给创建好的对象进行默认的初始化、及对类中构造器的调用
类中的构造器也成为构造方法，是进行创建对象时必须调用的。
构造器的特点：
- 必须与类的名字相同
- 必须没有返回类型，不能写void

05 构造器详解

在新建类时，即使什么内容不不写，也会自动创建一个构造器方法。

	public class Person(){
		// 编译时默认自动生成
		public Person(){}
	}

06 创建对象内存分析

07 简单小结类与对象

类与对象
- 类是一个模板，抽象；
- 对象是一个具体的实例
方法
- 定义、调用
对象的引用
- 引用类型：基本类型（8种）、引用类型
- 对象是通过引用来操作的栈-->堆（地址）
属性：
- 字段 Field、成员变量
- 默认初始化
  - 数字： 0， 0.0
  - char： u0000
  - boolean： false
  - 引用类型： null
- 修饰符属性类型属性名 = 属性值
方法
对象的创建和使用
- 必须使用 new 关键字创造对象，要有构造器
- 对象的属性
- 对象的方法
类
- 静态的属性（属性）
- 动态的行为（方法）

08 封装详解

高内聚，低耦合
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉
- 低耦合：仅暴露少量的方法给外部使用
封装（数据的隐藏）
- 通常应禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问，这称为信息隐藏。
属性私有，get/set

优点：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加了

09 什么是继承

继承的本质是对一批类的抽象，从而实现对现实世界更好的建模
extends 的意思是“扩展”，子类是父类的扩展。
Java中类只有单继承，没有多继承。

关系：

继承是类和类之间的一种关系。除此之外还有依赖、组合、聚合等关系
继承关系的两个类，一个是子类（派生类），一个是父类（基类）。子类继承父类，用关键字extends来表示
子类和父类之间，从意义上讲应该具有 “is a”的关系

Java中所有的类都继承自object类；
super；
方法重写；

10 Super详解

父类中 private 私有的东西无法被继承
子类的无参构造中，默认构造了父类的无参构造（隐藏代码）

super：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或构造方法中
super和this不能同时调用构造方法

11 方法重写

重写都是方法的重写，与属性无关，都是共有的、非静态方法

父类的引用可以指向子类。方法的调用只和左边定义的数据类型有关。

	public class A extends B{}
	
	public class B{}
	
	B b = new A(); // b会调用B的静态方法

静态方法和非静态方法区别很大，子类重写了父类的方法时，还会调用子类的方法。

重写：需要有继承关系，子类重写父类的方法。方法必须一致，方法体不同。

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，不能缩小
- public > protected > default > private
抛出的异常：范围可以缩小，不能扩大

为什么需要重写：

父类的功能，子类不一定需要，或不一定满足
alt + insert , override

12 什么是多态

同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件：
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
多态是方法的多态，属性没有多态性
适用于动态编译，增强可扩展性

package com.kuang.oop.demo02;

/**
 * 测试类
 *
 * @author maple_w
 * Created on 21/07/12 012 21:50
 */
public class application {
    public static void main(String[] args) {

        // 一个对象的实际类型是确定的
        // new Student();
        // new Person();

        // 可以指向的引用类型就不确定了
        Student s1 = new Student();
        // 父类的引用指向子类
        Person s2 = new Student();
        Object s3 = new Student();

        // 子类重写了父类的方法，执行子类的方法
        s2.run(); // son
        s1.run(); // son

        // s2.eat(); // 无法直接执行

        // 对象能够执行的方法主要看左边的类型，和右边关系不大。
        // Student 子类，能调用的方法都是自己的或者继承父类的
        // Person 父类，可以指向子类，但是不能调用子类独有的方法
    }
}

package com.kuang.oop.demo02;

/**
 * 人物类
 *
 * @author maple_w
 * Created on 21/07/12 012 21:50
 */
public class Person {
    public void run(){
        System.out.println("run");
    }
}

package com.kuang.oop.demo02;

/**
 * 学生类
 *
 * @author maple_w
 * Created on 21/07/12 012 21:50
 */
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}

13 instanceof 和类型转换

instanceof 判断类型

package com.kuang.oop.demo03;

/**
 * 测试类
 *
 * @author maple_w
 * Created on 21/07/12 012 22:04
 */
public class application {
    public static void main(String[] args) {

        // Object > String
        // Object > Person > Student
        // Object > Person > Teacher
        Object o = new Student();

        System.out.println(o instanceof Student); // true
        System.out.println(o instanceof Person); // true
        System.out.println(o instanceof Teacher); // false
        System.out.println(o instanceof Object); // true
        System.out.println(o instanceof String); // false

        System.out.println("==================");

        Person p = new Student();
        System.out.println(p instanceof Student); // true
        System.out.println(p instanceof Person); // true
        // System.out.println(p instanceof Teacher); // 编译报错
        System.out.println(p instanceof Object); // true
        // System.out.println(p instanceof String); // 编译报错

        System.out.println("==================");

        Student s = new Student();
        System.out.println(s instanceof Student); // true
        System.out.println(s instanceof Person); // true
        // System.out.println(s instanceof Teacher); // 编译报错
        System.out.println(s instanceof Object); // true
        // System.out.println(s instanceof String); // 编译报错
    }
}

子类转换为父类，向上转型；
父类转换为子类，向下转型，需要强制转换；
子类转换为父类时，可能丢失自己本来的一些方法。

14 static关键字详解

静态变量、非静态变量
静态方法、非静态方法

package com.kuang.oop.demo04;

/**
 * static
 *
 * @author maple_w
 * Created on 21/07/12 012 22:42
 */
public class Student {

    private static int age; // 静态变量
    private double score; // 非静态变量

    public void run(){} // 非静态方法

    public static void go(){} // 静态方法

    public static void main(String[] args) {

        go();
        Student.go();
        new Student().run();

        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

静态代码块
- 静态代码块最先执行，且只执行依次
- 然后执行匿名代码块
- 最后执行构造方法
静态导入包

package com.kuang.oop.demo04;

// 静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

/**
 * 静态代码块
 *
 * @author maple_w
 * Created on 21/07/12 012 22:44
 */
public class Person {
    {
        // 匿名代码块
        System.out.println("匿名代码块"); // 2.
    }

    static {
        // 静态代码块 只会执行一次
        System.out.println("静态代码块"); // 1.
    }

    public Person(){
        System.out.println("构造方法"); // 3.
    }

    public static void main(String[] args) {
		random();
	
        Person person = new Person();
        // 静态代码块
        // 匿名代码块
        // 构造方法
        System.out.println("================");
        Person person1 = new Person();
        // 匿名代码块
        // 构造方法
    }
}

15 抽象类

abstract 修饰符可以用来修饰方法，也可以修饰类。如果修饰方法，该方法就是抽象方法，如果修饰类，该类就是抽象类。
抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。
抽象类不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
抽象类是一种类，只能单继承。接口可以多继承。

16 接口的定义与实现

类与接口：

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范（抽象方法）
声明类的关键字：class，声明接口的关键字 interface

接口相关：

接口就是规范，定义的是一组规则，体现在现实世界中”如果你是...则必须能...“
接口的本质是契约，就像法律一样，制定好之后大家都遵守。
面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。设计模式所研究的，就是如何合理的去抽象
实现了接口的类需要重写接口中的方法；
接口中的所有定义都是抽象的 public abstract；
接口不能被实例化，接口中没有构造方法
implements 可以实现多个接口

17 N种内部类

内部类：在一个类的内部再定义一个类

成员内部类

package com.kuang.oop.demo07;

/**
 * 外部类
 *
 * @author maple_w
 * Created on 21/07/13 013 8:28
 */
public class Outer {

	private int id = 10;

	public void out(){
		System.out.println("外部类方法");
	}

	public class Inner{
		public void in(){
			System.out.println("内部类方法");
		}

		// 获得外部类的私有属性
		public void getID(){
			System.out.println(id);
		}
	}
}

package com.kuang.oop.demo07;

/**
 * 测试类
 *
 * @author maple_w
 * Created on 21/07/13 013 8:29
 */
public class application {
	public static void main(String[] args) {

		Outer outer = new Outer();
		// 通过外部类实例化 成员内部类
		Outer.Inner inner = outer.new Inner();
		inner.in(); // 内部类方法
		inner.getID(); // 10

	}
}

静态内部类

	public static class Inner1{
		public void in(){
			System.out.println("静态内部类");
		}
		// 无法获取到外部类的属性
	}

局部内部类

	// 一个java类中可以有多个class类，但只能有一个public class  
	class A{  
	}
	
	public class Ounter{
		public void method(){
			class Inner{
			}
		}
	}

匿名内部类

package com.kuang.oop.demo07;

/**
 * 匿名内部类
 *
 * @author maple_w
 * Created on 21/07/13 013 8:38
 */
public class Test {
	public static void main(String[] args) {
		// 匿名内部类，没有名字的初始化类,不用将实例保存到变量中
		new Apple().eat();
	}
}

class Apple{
	public void eat(){
		System.out.println("1");
	}
}

这篇关于狂神Java SE （七）面向对象的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

狂神Java SE （七）面向对象

01 什么是面向对象

02 回顾方法的定义

03 回顾方法的调用

04 类与对象的创建

05 构造器详解

06 创建对象内存分析

07 简单小结类与对象

08 封装详解

09 什么是继承

10 Super详解

11 方法重写

12 什么是多态

13 instanceof 和类型转换

14 static关键字详解

15 抽象类

16 接口的定义与实现

17 N种内部类

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯