(四)java面向对象基础

1.面向对象的概述

1.1 面向对象和面向过程

1. 面向过程：强调的是功能行为，以函数为最小单位
2. 面向对象：面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚
   合、多态等。
3. 面向对象的三大特征

• 封装(Encapsulation)
• 继承(Inheritance)
• 多态(Polymorphism)
  将大象装到冰箱里面向对象和面向过程步骤如下
  

1.2 程序设计七大原则

1. 单一职责原则（Single Responsibility Principle）：每一个类应该专注于做一件事情。
2. 里氏替换原则（Liskov Substitution Principle）：超类存在的地方，子类是可以替换的。
3. 依赖倒置原则（Dependence Inversion Principle）：实现尽量依赖抽象，不依赖具体实现。
4. 接口隔离原则（Interface Segregation Principle）：应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。
5. 迪米特法则（Law Of Demeter）：又叫最少知识原则，一个软件实体应当尽可能少的与其他实体发生相互作用。
6. 开闭原则（Open Close Principle）：面向扩展开放，面向修改关闭。
7. 组合/聚合复用原则（Composite/Aggregate Reuse Principle CARP）：尽量使用合成/聚合达到复用，尽量少用继承。原则： 一个类中有另一个类的对象。

1.3 类的成员

属性和行为

• 属性：对应类中的成员变量Field
• 行为：对应类中的成员方法Method

1.4 内存分析

现在有如下代码

package test1;
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println(p1);
        p1.name = "马云";
        Person p2 = new Person();
    }
}
class Person{
    String name;
    int age;
    public String walking(){
        return "人在走路";
    }
    public void display(){
        System.out.println("名字=" + name + ",年龄=" + age);
    }
}

内存状态图如下：

方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据

1.5 属性

• 变量的分类：
  • 在方法体外，类体内声明的变量成为成员变量
  • 在方法体内部声明的变量成为局部变量

	成员变量	局部变量
声明的位置	直接声明在类中	方法形参或内部、代码块内、构造器内
修饰符	private public static final	不能用权限修饰符，但可使用final
初始值	有默认初始值	没有默认初始值
内存加载位置	堆空间或静态域内	栈空间

引用类型的系统默认值为null

public class Test1 {

    public static void main(String[] args) {
        System.out.println(new Person());//成员变量初始值
    }
}

public class Person {
    private int i;
    short s;
    private char c;
    String str;
    int[] arr;

    @Override
    public String toString() {
        return "" + i + s + (int)c + str + arr;
    }
}

1.6 方法

1.6.1 方法的重载

• 与返回值类型无关（不同返回值类型的同名同参方法只能是重复）
• 方法名必须相同
• 参数列表不完全相同

package test4;
public class Test1 {
    public static void print(int i){};
    public static void print(float f){};
    public static void print(String s){};

    public static void main(String[] args) {
        print(3);
        print(1.2f);
        print("hello");//方法的重载
    }
}

1.6.2 可变参数

• 格式：public void display(int... arr)
• 个数是可变的：0个也可以
• 可变参数要放在最后即：public void display(String name, int... arr)
• 一个方法中只能声明一个可变参数

package test4;
public class Test2 {//可变参数
    public static void show(String[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void display(String... arr) {//可变参数
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void display(String name, int... arr) {
        System.out.println("name:" + name);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void main(String[] args) {
        String[] strs = {"a", "b", "c"};
        Test2.show(strs);
        System.out.println("===========");
        display();//可变参数的形参个数可以为0
        System.out.println("========");
        display("mickey", "a", "b");
        display("mickey", 1, 2, 3, 4, 5, 6);
    }
}

1.6.3 参数传递

1. 形参和实参
   • 形参：方法声明时的参数
   • 实参：方法调用时实际传给形参的参数值

2.数据类型传递

• 形参是基本数据类型”：将实参基本数据类型变量的“数据值”传递给形参
• 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

1.6.4 递归方法

package test6;
import java.sql.PreparedStatement;
public class Test {//递归方法
    public static void main(String[] args) {//计算1到100所有自然数的乘积
        int n = 5;
        System.out.println( recursion(n));
    }
    public static int recursion(int n) {//递归
        if (n == 1)
            return 1;
        int sum = n * recursion(n -1);
        return sum;
    }
}

2. 面向对象基础

2.1 封装

目的：追求高内聚，低耦合–>隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想

• 高内聚：类的内部数据操作新界自己完成，不允许外部干涉
• 低耦合：仅对外暴露少量的方法用于使用

public class Test1 {//get 和 set 方法是使用，体现了封装的特点
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.setLegs(4);
        System.out.println(animal.getLegs());
    }
}
class Animal {
    private int legs;
    public int getLegs() {
        return legs;
    }
    public void setLegs(int legs) {
        if (legs == 0 || legs == 2 || legs == 4)
            this.legs = legs;
        else {
            System.out.println("输入错误，请重新输入");
        }
    }
}

2.2 构造函数

• 特征
  • 与类名相同
  • 不能有返回类型
  • 不能被static final synchronized abstract native修饰，不能有return语句返回值

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

类成员变量的初始值为：

• 先执行默认初始值即：null
• 在进行显式初始值即：private int a = 10;
• 在进行构造器初始化即：public Person(){}
• 一旦定义了显示构造器，那么隐式构造器将不能再使用

2.3 javaBean

所谓的JavaBean，是指符合瑞啊标准的java类

• 类是公共的
• 有一个无参的公共的构造器
• 有属性，且有对应的get、set方法

package test10;
public class Test1 {//javaBean
    private String name;
    private int age;
    public Test1() {//无参构造器
    }
    //get 和set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

2.4 this 关键字

• 它在方法内部使用，即这个方法所属对象的引用；
• 它在构造器内部使用，表示该构造器正在初始化的对象。
• this 可以调用类的属性、方法和构造器
• 当在方法内需要用到调用该方法的对象时，就用this。
• 具体的：我们可以用this来区分属性和局部变量。比如：this.name = name;

2.5 package和import

package

• 文件夹
• 包可包含类和子包，划分项目层次，便于管理
• 解决类命名冲突的问题
• 控制访问权限

import使用：import test1；（test1为一个包）

java中常用的包

1. java.lang----包含一些Java语言的核心类， 如String、 Math、 Integer、 System和Thread， 提供常用功能
2. java.net----包含执行与网络相关的操作的类和接口。
3. java.io ----包含能提供多种输入/输出功能的类。
4. java.util----包含一些实用工具类， 如定义系统特性、 接口的集合框架类、 使用与日期日历相关的函数。
5. java.text----包含了一些java格式化相关的类
6. java.sql----包含了java进行JDBC数据库编程的相关类/接口
7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits） 的多个类， 这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S