Java 面向对象

最新推荐文章于 2023-07-20 20:11:43 发布

四两迷糊

最新推荐文章于 2023-07-20 20:11:43 发布

阅读量408

点赞数 2

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_53605652/article/details/131837352

版权

1 面向对象概述

1.1 面向过程和面向对象

1. 面向对象：Object Oriented Programming

面向过程，强调的是功能行为，以函数为最小单位

2. 面向过程：Procedure Oriented Programming

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

3. 面向对象的三大特征

封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism

把大象装到冰箱的面向对象设计和面向过程设计如下：
在这里插入图片描述

1.2 概述

类(Class)和对象(Object)是面向对象的核心概念。

类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
可以理解为：类 = 抽象概念的人；
对象 = 实实在在的某个人面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计

1.3 类的成员

现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么，Java中用类class来描述事物也是如此。常见的类的成员有：

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

Field = 属性 = 成员变量，Method = (成员)方法 = 函数
在这里插入图片描述

public class Person {
 
 String name;
 int age;
 /**
 - sex:1 表明是男性
 - sex:0 表明是女性
 */
 
 int sex; 
 public void study(){
 System.out.println("studying");
 }
 
 public void showAge(){
 System.out.println("age:" + age);
 }
 
 public int addAge(int i){
 age += i;
 return age;
 }
}

1.4 内存解析

1. 创建对象

class Person{
    int age;
    void shout(){
   System.out.println(“oh,my god! I am ” + age);
 }
}

Person p1 = new Person();执行完后的内存状态。其中类定义如下：
在这里插入图片描述
2. 使用对象

class PersonTest{
    public static void main(String[] args) { //程序运行的内存布局如下图

        Person p1 = new Person();
        Person p2 =new Person();
        p1.age = -30;
        p1.shout();
        p2.shout();
   }
}

在这里插入图片描述

3. 内存区域

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

4. 代码分析

class Person{//人类
    //1.属性
    String name;//姓名
    int age = 1;//年龄
    boolean isMale;//是否是男性
}

class PersonTest{
    main(){
        Person p = new Person();
        Person p1 = new Person();
        p1.name = “Tom”;
        Person p2 = p1;
 }
}

在这里插入图片描述
根据下列代码，画出内存图:

class Car{
    String color = "red";
    int num = 4;
    void show(){
   System.out.println("color="+color+"..num="+num);
 }
}

class CarTest {
    public static void main(String[] args) {
        Car c1 = new Car(); //建立对象c1

        Car c2 = new Car(); //建立对象c2

        c1.color = "blue"; //对对象的属性进行修改

        c1.show(); //使用对象的方法

        c2.show();
   } 
}

在这里插入图片描述

1.5 属性（Field）

1. 变量的分类

在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。

2. 成员变量默认初始化值

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;
   }
    public static void main(String[] args) {
        System.out.println(new Person());
   }
}

//结果 000nullnull

1.6 方法（Method)

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
将功能封装为方法的目的是，可以实现代码重用，简化代码
Java里的方法不能独立存在，所有的方法必须定义在类里。
格式：

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
    方法体程序代码
 return 返回值;
｝

计算圆的面积:

/*
 * 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
 */
//测试类
public class CircleTest {
 public static void main(String[] args) { 
 Circle c1 = new Circle(); 
 c1.radius = 2.1; 
 
 //对应方式一：
// double area = c1.findArea();
// System.out.println(area);

 //对应方式二：
 c1.findArea();
 }
}

//圆
class Circle{
 //属性
 double radius;
 //求圆的面积
 
 //方式一：
// public double findArea(){
// double area = Math.PI * radius * radius;
// return area;
// }

 //方式二：
 public void findArea(){
 double area = Math.PI * radius * radius;
 System.out.println("面积为：" + area);
 } 
}

1.6.1 方法的重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。
调用时，根据方法参数列表的不同来区别。

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}
public class PrintStream {
    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!");
   }
}

使用案例：

编写程序，定义三个重载方法并调用。方法名为mOL。

三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的main ()方法中分别用参数区别调用三个方法。

定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值，并分别调用三个方法。

public class OverloadExer {
 
 //1. 如下的三个方法构成重载

 public void mOL(int i){
 System.out.println(i * i);
 
 }
 public void mOL(int i,int j){
 System.out.println(i * j);
 }
 
 public void mOL(String s){
 System.out.println(s);
 }
 
 //2.如下的三个方法构成重载

 public int max(int i,int j){
 return (i > j)? i : j;
 }
 public double max(double d1,double d2){
 return (d1 > d2)? d1 : d2;
 }
 public double max(double d1,double d2,double d3){
 double max = (d1 > d2)? d1 : d2;
 return (max > d3)? max : d3;
 }
}

1.6.2 可变参数

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);

//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String… books);

声明格式：方法名(参数的类型名 …参数名)
可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
可变个数形参的方法与同名的方法之间，彼此构成重载
可变参数方法的使用与方法参数部分使用数组是一致的
方法的参数部分有可变形参，需要放在形参声明的最后
在一个方法的形参位置，最多只能声明一个可变个数形参

public class Test2 {
    public void show(String[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
       }
   }
    public void display(String... arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
       }
   }
    public 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) {
        Test2 t2 = new Test2();
        String[] strs = new String[] {"a", "b", "c"};
        t2.show(strs);
        System.out.println("--------------");
        String[] strs2 = new String[] {"aa", "bb", "cc"};
        t2.display(strs2);
        System.out.println("--------------");
        //可变参数用法

        t2.display();

//       t2.show(); //报错

        System.out.println("--------------");
        t2.display("mickey", "a", "b");
        t2.display("mickey", 1, 2, 3);
   }
}

1.6.3 参数传递

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

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

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

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

基本数据类型参数传递

 public static void main(String[] args) {
        int x = 5;
        System.out.println("修改之前x = " + x);
        // x是实参

        change(x);
        System.out.println("修改之后x = " + x);
   }
    public static void change (int x){
        System.out.println("change:修改之前x = " + x);
        x = 3;
        System.out.println("change:修改之后x = " + x);
   }

在这里插入图片描述
2. 引用类型参数传递

public static void main(String[] args) {
    Person obj = new Person();
    obj.age = 5;
    System.out.println("修改之前age = " + obj.age);

    change(obj);
    System.out.println("修改之后age = " + obj.age);
}

public static void change(Person obj) {
    System.out.println("change:修改之前age = " + obj.age);
    obj.age = 3;
    System.out.println("change:修改之后age = " + obj.age);
}

其中Person类定义为：

class Person{
 int age; 
}

在这里插入图片描述
3. 案例1

public class ValueTransferTest1 {
 public static void main(String[] args) {
 
 int m = 10;
 int n = 20;
 
 System.out.println("m = " + m + ", n = " + n);
 
 ValueTransferTest1 test = new ValueTransferTest1();
 test.swap(m, n);
 
 System.out.println("m = " + m + ", n = " + n);
 }
 
 public void swap(int m,int n){
 int temp = m ;
 m = n;
 n = temp;
 }
}

在这里插入图片描述
4. 案例2

public class ValueTransferTest2 {
 
 public static void main(String[] args) {
 
 Data data = new Data();
 
 data.m = 10;
 data.n = 20;
 
 System.out.println("m = " + data.m + ", n = " + data.n);
 
 ValueTransferTest2 test = new ValueTransferTest2();
 test.swap(data);
 
 System.out.println("m = " + data.m + ", n = " + data.n);
 
 }
 
 public void swap(Data data){
 int temp = data.m;
 data.m = data.n;
 data.n = temp;
 }
 }
 
class Data{

 int m;
 int n;

}

在这里插入图片描述

1.6.4 递归方法

递归方法：一个方法体内调用它自身

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

 public static void main(String[] args) {
//        int sum = 0;
//        for (int i = 1; i <= 100; i++) {
//            sum += i;
//        }
//        System.out.println(sum);

       int sum = getSum(100);

        System.out.println(sum);
    }

    public static int getSum(int n) {
        if (n == 1) { //必须要有跳出递归的条件
            return 1;
        } else {
            return n + getSum(n -1);
        }
    }

2 面向对象基础

2.1 封装

为什么需要封装？封装的作用和含义？

我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
我要开车，…

我们程序设计追求“高内聚，低耦合”。

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅对外暴露少量的方法用于使用。

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

（1）属性封装的案例1：

class Animal {
 public int legs;
 public void eat(){
 System.out.println("Eating");
 }
 public void move(){
 System.out.println("Moving.");
 }
}

public class Zoo {
 public static void main(String args[]) {
 Animal xb = new Animal();
 xb.legs = 4; //问题：xb.legs = -1000，解决方式将legs属性封装起来，防止乱用

 System.out.println(xb.legs);
 xb.eat();
 xb.move();
 }
}

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()**和setXxx()**实现对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
便于修改，增强代码的可维护性；

class Animal {
    private int legs;// 将属性legs定义为private，只能被Animal类内部访问

    public void setLegs(int i) { // 在这里定义方法 eat() 和 move()

        if (i != 0 && i != 2 && i != 4) {
            System.out.println("Wrong number of legs!");
            return;
       }
        legs = i;
   }
    public int getLegs() {
   return legs;
   }
}

public class Zoo {
 public static void main(String args[]) {
   Animal xb = new Animal();
        xb.setLegs(4); // xb.setLegs(-1000);

        //xb.legs = -1000; // 非法

        System.out.println(xb.getLegs());
 }
}

2.2 构造函数

构造器的特征

它具有与类相同的名称
它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用：创建对象；给对象进行初始化

如：Order o = new Order(); Person p = new Person(“Peter”,15);
如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

案例（1）

public class Animal {
    private int legs;
    // 构造器

    public Animal() {
    legs = 4;
   } 
    public void setLegs(int i) {
   legs = i;
   }
    public int getLegs() {
    return legs;
   }
}

根据参数不同，构造器可以分为如下两类：
- 隐式无参构造器（系统默认提供 )
- 显式定义一个或多个构造器（无参、有参）
Java语言中，每个类都至少有一个构造器
默认构造器的修饰符与所属类的修饰符一致一旦显式定义了构造器，则系统不再提供默认构造器
一个类可以创建多个重载的构造器
父类的构造器不可被子类继承

案例（2）

创建程序,在其中定义两个类：Person和PersonTest类。定义如下：用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。

前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。
修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值

public class Person {
 
 private int age;
 private String name;
 public Person(){
 age = 18;
 }
 
 public Person(String n,int a){
 name = n;
 age = a;
 }
 
 
 public void setAge(int a){
 if(a < 0 || a > 130){

// throw new RuntimeException("传入的数据非法！");

 System.out.println("传入的数据非法！");
 return;
 }
 age = a;
 
 }
 
 public int getAge(){
 return age;
 }
 
 public void setName(String n){
 name = n;
 }
 public String getName(){
 return name;
 }
 
}

public class PersonTest {
 public static void main(String[] args) {
 
 Person p1 = new Person();
 
 p1.setAge(12);
 
 System.out.println("年龄为：" + p1.getAge());
 
 Person p2 = new Person("Tom", 21);
 System.out.println("name = " + p2.getName() + ",age = " + 

p2.getAge());
 
 }
}

案例（3）

定义Student类,有4个属性：
- String name;
- int age;
- String school;
- String major
定义Student类的3个构造器:
- 第一个构造器Student(String n, int a)设置类的name和age属性；
- 第二个构造器Student(String n,int a, String s)设置类的name, age 和school属性；
- 第三个构造器Student(String n, inta, String s, String m)设置类的name, age ,school和major属性；
在main方法中分别调用不同的构造器创建的对象，并输出其属性值。

赋值顺序

截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位置，并指明赋值的先后顺序。
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过“对象.属性“或“对象.方法”的方式赋值
赋值的先后顺序：
① - ② - ③ - ④

2.3 JavaBean

所谓javaBean，是指符合如下标准的Java类：

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

public class JavaBean {
    private String name; // 属性一般定义为private

    private int age;
    public JavaBean() {
   }
    public int getAge() {
    return age;
   }
    public void setAge(int a) {
   age = a;
   }
    public String getName() {
    return name;
   }
   public void setName(String n) {
   name = n;
   }
}

2.4 this关键词

在Java中，this关键字比较难理解，它的作用和其词义很接近。

它在方法内部使用，即这个方法所属对象的引用；
它在构造器内部使用，表示该构造器正在初始化的对象。

this 可以调用类的属性、方法和构造器

当在方法内需要用到调用该方法的对象时，就用this。
具体的：我们可以用this来区分属性和局部变量。比如：this.name = name;

案例（1）

class Person{ // 定义Person类

    private String name ;
    private int age ;
    public Person(String name,int age){
    this.name = name ; 
   this.age = age ; 
   }
    public void getInfo(){
   System.out.println("姓名：" + name) ;
    this.speak();
   }
    public void speak(){
   System.out.println(“年龄：” + this.age);
   }
}

案例（2）

class Person{ // 定义Person类

    String name;
    Person(String name){
    this.name = name;
   }
    public void getInfo(){
   System.out.println("Person类 --> " + this.name) ; 
   }
    public boolean compare(Person p){
   return this.name==p.name;
   } 
}

public class PersonTest{
public static void main(String args[]){
        Person per1 = new Person("张三") ;
        Person per2 = new Person("李四") ;
        per1.getInfo() ; // 当前调用getInfo()方法的对象是per1

        per2.getInfo() ; // 当前调用getInfo()方法的对象是per2

        boolean b = per1.compare(per2);
   } 
}

2.5 package和import

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)，包通常用小写单词标识。通常使用所在公司域名的倒置： com.lxs.xxx

包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
包可以包含类和子包，划分项目层次，便于管理
解决类命名冲突的问题
控制访问权限

package com.lxs.demo;
import javax.servlet.*;
import java.io.PrintWriter;
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
}

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性.

Java中常用的包

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

四两迷糊

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java 面向对象

类(Class)和对象(Object)是面向对象的核心概念。类是对一类事物的描述，是抽象的、概念上的定义对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人面向对象程序设计的重点是类的设计类的设计，其实就是类的成员的设计。
复制链接

扫一扫