Java300集学习笔记----Day3（面向对象基础部分）

最新推荐文章于 2024-08-03 16:26:28 发布

NQGL.

最新推荐文章于 2024-08-03 16:26:28 发布

阅读量128

点赞数

分类专栏： Java 文章标签：学习 java

本文链接：https://blog.csdn.net/weixin_45595929/article/details/129902408

版权

Java 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

面向对象基础部分

1. 面向过程和面向对象的区别
2. 类和对象
3. 构造方法（构造器constructor）
- 3.1 构造方法的基础用法
- 3.2 构造方法的重载
4. 面向对象的内存分析（了解）
5. 垃圾回收机制（了解）
6. this、static关键字
7 包机制（package、import）

1. 面向过程和面向对象的区别

面向过程思想：思考问题时，我们首先思考“怎么按步骤实现?”并将步骤对应成方法，一步一步，最终完成。这个适合简单任务，不需要过多协作的情况下。比如，如何开车?我们很容易就列出实现步骤：1. 发动车 2. 挂挡 3.踩油门 4. 走你
面向对象(Object)思想：更契合人的思维模式。我们首先思考的是“怎么设计这个事物?” 比如思考造车，我们就会先思考“车怎么设计?”，而不是“怎么按步骤造车的问题”。这就是思维方式的转变。
面向对象具有三大特征：封装性、继承性和多态性，面向过程没有继承性和多态性，并且面向过程的封装只是封装功能，而面向对象可以封装数据和功能。所以面向对象优势更明显。

2. 类和对象

2.1 类和对象的概念

对象是具体的事物;类是对对象的抽象;
类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。

2.2 类的定义

【示例】：类的定义

// 每一个源文件必须有且只有一个public class，并且类名和文件名保持一致！
public class Car { 
}
class Tyre { // 一个Java文件可以同时定义多个class
}
class Engine {
}
class Seat {
}

上面的类定义好后，没有任何的其他信息，就跟我们拿到一张张图纸，但是纸上没有任何信息，这是一个空类，没有任何实际意义。所以，我们需要定义类的具体信息。对于一个类来说，一般有三种常见的成员：属性field、方法method、构造器constructor。这三种成员都可以定义零个或多个。
【示例】：

public class SxtStu {
    //属性（成员变量）
    int id;
    String sname;
    int age;
    //方法
    void study(){
        System.out.println("我正在学习！");
    }
    //构造方法（方法名和类名保持一致）
    SxtStu(){
    }
    public static void main(String[] args) {
        SxtStu s1 = new SxtStu();
        s1.id = 10001;
        s1.sname = "张三";
        s1.age = 18;
        s1.study();
        System.out.println(s1.id+"\t"+s1.sname+"\t"+ s1.age);
    }
}

2.3 属性

属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

成员变量的默认值
属性定义格式：[修饰符] 属性类型属性名 = [默认值] ;

2.4 方法

方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法定义格式：

[修饰符] 方法返回值类型方法名(形参列表) {
// n条语句
}

3. 构造方法（构造器constructor）

3.1 构造方法的基础用法

构造方法(constructor)，用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，目的是对象的初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器，从而返回该类的实例，是一种特殊的方法。
声明格式：

[修饰符] 类名(形参列表){
//n条语句
}

要点：

通过new关键字调用！！
构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加!
构造器的方法名必须和类名一致！

【示例】：定义一个“点”(Point)类用来表示二维空间中的点(有两个坐标)。

/**
* 定义一个“点”(Point)类用来表示二维空间中的点(有两个坐标)。要求如下：

*(1) 可以生成具有特定坐标的点对象。

*(2) 提供可以设置坐标的方法。

*(3)提供可以计算该“点”距另外一点距离的方法。
*/
class Point {
    double x, y;
    public Point(double _x, double _y) {
        x = _x;
        y = _y;
    }
    public double getDistance(Point p) {
        return Math.sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
    }
}
public class Test {
    public static void main(String[] args) {
        Point p = new Point(3.0, 4.0);
        Point origin = new Point(0.0, 0.0);
        System.out.println(p.getDistance(origin));
    }
}

3.2 构造方法的重载

【示例】构造方法重载(创建不同用户对象)

public class User {
    int id; // id
    String name; // 账户名
    String pwd; // 密码
    public User() {
 
    }
    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    public static void main(String[] args) {
        User u1 = new User();
        User u2 = new User(101, "高小七");
        User u3 = new User(100, "高淇", "123456");     
    }
}

注意：如果方法构造中形参名与属性名相同时，需要使用this关键字区分属性与形参。如示例所示：this.id 表示属性id;id表示形参id

4. 面向对象的内存分析（了解）

内存分析总结：

同一类的每个对象有不同的成员变量存储空间
同一类的每个对象共享该类的方法
方法区存放的是静态变量，类或者static

5. 垃圾回收机制（了解）

6. this、static关键字

6.1 this关键字

创建对象的过程：
构造方法是创建Java对象的重要途径，通过new关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造器负责创建。
创建一个对象分为如下四步：
　　1. 分配对象空间，并将对象成员变量初始化为0或空
　　2. 执行属性值的显示初始化
　　3. 执行构造方法
　　4. 返回对象的地址给相关的变量
this的本质就是“创建好的对象的地址”! 由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代表“当前对象” 。
this最常的用法：
　　1. 在程序中产生二义性之处，应使用this来指明当前对象；普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
　　2. 使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
　　3. this不能用于static方法中。（this从属于对象，static从属于类）
【示例】this代表“当前对象”

public class User {
    int id;        //id
    String name;   //账户名
    String pwd;   //密码
 
    public User() {
    }
    public User(int id, String name) {
        System.out.println("正在初始化已经创建好的对象："+this);
        this.id = id;   //不写this，无法区分局部变量id和成员变量id
        this.name = name;
    }
    public void login(){
        System.out.println(this.name+",要登录！");  //不写this效果一样
    }  
     
    public static void main(String[] args) {
        User  u3 = new User(101,"高小七");
        System.out.println("打印高小七对象："+u3);
        u3.login();
    }
}

【示例】this()调用重载构造方法

public class TestThis {
    int a, b, c;
 
    TestThis() {
        System.out.println("正要初始化一个Hello对象");
    }
    TestThis(int a, int b) {
        // TestThis(); //这样是无法调用构造方法的！
        this(); // 调用无参的构造方法，并且必须位于第一行！
        a = a;// 这里都是指的局部变量而不是成员变量
// 这样就区分了成员变量和局部变量. 这种情况占了this使用情况大多数！
        this.a = a;
        this.b = b;
    }
    TestThis(int a, int b, int c) {
        this(a, b); // 调用带参的构造方法，并且必须位于第一行！
        this.c = c;
    }
 
    void sing() {
    }
    void eat() {
        this.sing(); // 调用本类中的sing();
        System.out.println("你妈妈喊你回家吃饭！");
    }
 
    public static void main(String[] args) {
        TestThis hi = new TestThis(2, 3);
        hi.eat();
    }
}

6.2 static关键字

在类中，用static声明的成员变量为静态成员变量，也称为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。
它有如下特点：
　　1. 为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
　　2. 对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享!!
　　3. 一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)
　　4. 在static方法中不可直接访问非static的成员。

核心要点：
static修饰的成员变量和方法，从属于类。
普通变量和方法从属于对象的。

【示例】

public class User2 {
    int id; // id
    String name; // 账户名
    String pwd; // 密码
     
    static String company = "北京尚学堂"; // 公司名称
     
     
    public User2(int id, String name) {
        this.id = id;
        this.name = name;
    }
     
    public void login() {
        printCompany();
        System.out.println(company); 
        System.out.println("登录：" + name);
    }
     
    public static void printCompany() {
//         login();//调用非静态成员，编译就会报错
        System.out.println(company);
    }
     
    public static void main(String[] args) {
        User2 u = new User2(101, "高小七");
        User2.printCompany();
        User2.company = "北京阿里爷爷";
        User2.printCompany();
    }
}

内存分布图

6.3 静态初始化块

构造方法用于对象的初始化!
静态初始化块，用于类的初始化操作!
在静态初始化块中不能直接访问非static成员。

【示例】

public class User3 {
    int id;        //id
    String name;   //账户名
    String pwd;   //密码
    static String company; //公司名称
    static {
        System.out.println("执行类的初始化工作");
        company = "北京尚学堂";
        printCompany();
    }  
    public static void printCompany(){
        System.out.println(company);
    }  
    public static void main(String[] args) {
        User3  u3 = new User3();
    }
}

7 包机制（package、import）

我们通过package实现对类的管理，package的使用有两个要点：

1. 通常是类的第一句非注释性语句。

2. 包名：域名倒着写即可，再加上模块名，便于内部管理类。
　　
注意事项：

1. 写项目时都要加包，不要使用默认包。

2. com.gao和com.gao.car，这两个包没有包含关系，是两个完全独立的包。只是逻辑上看起来后者是前者的一部分。

7.1 JDK中的主要包

JDK中的主要的包

7.2 导入类 import

如果我们要使用其他包的类，需要使用import导入。
注意要点：

1. Java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。

2. 如果导入两个同名的类，只能用包名+类名来显示调用相关类
　　
【示例】导入同名类的处理

import java.sql.Date;
import java.util.*;//导入该包下所有的类。会降低编译速度，但不会降低运行速度。
 
public class Test{
    public static void main(String[] args) {
        //这里指的是java.sql.Date
        Date now; 
        //java.util.Date因为和java.sql.Date类同名，需要完整路径
        java.util.Date  now2 = new java.util.Date();
        System.out.println(now2);      
        //java.util包的非同名类不需要完整路径
        Scanner input = new Scanner(System.in);    
    }
}

7.3 静态导入（了解）

静态导入(static import)是在JDK1.5新增加的功能，其作用是用于导入指定类的静态属性和静态方法，这样我们可以直接使用静态属性和静态方法。
【示例】静态导入的使用

 //以下两种静态导入的方式二选一即可
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性

public class Test2{
    public static void main(String [] args){
        System.out.println(PI);
        System.out.println(random());
    }
}