Java核心卷（I）学习笔记（1）

最新推荐文章于 2024-09-12 08:54:42 发布

小小怪下士ss

最新推荐文章于 2024-09-12 08:54:42 发布

阅读量71

点赞数 1

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

本文链接：https://blog.csdn.net/qq_66104875/article/details/134084568

版权

Java学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

前言：

因为先前的Java学习是基于我学的教材，有些内容教材中并未涉及亦或是比较浅显。所以找来机械工业出版社的《Java核心技术卷I：基础知识》，来深入学习Java的一些基础知识。因为书中的前面的部分例如：数据类型、类型转换等，我学的教材中都有详细涉及，所以我打算从对象与类开始学习。不足之处还请多多指教。

1. 面向对象程序设计

面向对象程序设计（OOP）是当今主流的程序设计范型，Java是完全面向对象的，因此熟悉OOP才能更好的编写Java程序。面向对象的程序有对象组成，每个对象包含对用户公开的特定功能和隐藏的实现部分。程序中的对象可以来自标准库也可以自定义，从根本上讲只要对象能满足要求，就不关心其功能的具体实现过程。

在传统的结构化程序设计中，程序员首先要确定如何操作数据，再决定如何组织数据，以便数据操作。oop调换了这个次序，数据被放在第一位，然后再考虑操作数据的算法。对于一些规模小的问题，将其分解为过程的开发方式比较合适，但是对于一些规模大的问题，面向对象就更胜一筹。

2. 类、对象

类是构造对象的模板或蓝图，我们可以将类想象成对象的切割机。由类构造对象的过程称为创建类的实例。

封装从形式上看是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式。在对象中将数据称为实例域，操纵数据的过程称为方法。对于每个特定的类实例都有一组特定的实例域值，这些值的集合就是这个对象的当前状态。无论何时，只要向对象发出一个消息，它的状态都可能改变。

下面我根据自己的理解给出一个例子：

这里我创建一个学生类，类中包含有Id,age,address三个属性，在主类中创建对象并给出初始状态，然后输出状态。

package Exemple;

public class Stu {
    public static void main(String[] args) {
        Student stu1 = new Student(10001,21,"Beijing");//创建实例对象stu1
        Student stu2 = new Student(10002,20,"ShangHai");//创建实例对象stu2

        System.out.println("stu1: Id=" + stu1.getId() + ",age=" + stu1.getAge() + ",address=" + stu1.getAddress());//输出状态
        System.out.println("stu2: Id=" + stu2.getId() + ",age=" + stu2.getAge() + ",address=" + stu2.getAddress());//输出状态

    }
}

package Exemple;

public class Student {
    private int id;
    private int age;
    private String address;
    public Student(int i,int a,String ad)
    {
        id = i;
        age = a;
        address = ad;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public void setAddress(String address){
        this.address=address;
    }
    public String getAddress(){
        return address;
    }
}

然后我在主类中对对象stu1发送消息：

package Exemple;

public class Stu {
    public static void main(String[] args) {
        Student stu1 = new Student(10001,21,"Beijing");//创建实例对象stu1
        Student stu2 = new Student(10002,20,"ShangHai");//创建实例对象stu2
         stu1.setId(21001);//发送消息
         stu1.setAge(23);
         stu1.setAddress("YunNan");
        System.out.println("stu1: Id=" + stu1.getId() + ",age=" + stu1.getAge() + ",address=" + stu1.getAddress());//输出状态
        System.out.println("stu2: Id=" + stu2.getId() + ",age=" + stu2.getAge() + ",address=" + stu2.getAddress());//输出状态
 
    }
}

可以看到stu1的状态发生了改变。

在上例中我们创建了两个对象实例，要想使用OOP，一定要清楚对象的三个主要特性：

1.对象的行为：可以对对象施加哪些操作，或者可以对对象施加哪些方法。

2.对象的状态：当时施加那些方法后，对象如何响应。

3.对象的标识：如何辨别具有相同行为与状态的不同对象。

在Java中，使用构造器来构造新实例（对象），构造器用来构造并初始化对象，上例中我们就创建了两个实例，下面我们通过一个现有类（Date类）给出一个例子。构建对象时需要在构造器前加上new操作符，例如：new Date(),一般我们希望构造的对象可以多次使用，我们就可以将需要构造的对象放在一个变量中。Date birthday = new Date();

类之间的关系：

类与类之间常见的关系有：依赖、聚合、继承。

依赖：一个类的方法操纵另一个类的对象，我们就说一个类依赖于另一个类。我们应该尽可能减少依赖类的出现。

聚合：我们设有两个类A,B如果一个A类的对象包含了一些B类对象，我们就说这两个类存在聚合关系。

继承：顾名思义，就是一个类是由另一个类继承而来。

3. 自定义类

这里我们通过分步解析一个类，来了解实现自定义类的过程。

package Exemple;
import java.util.*;
public class Employee {
    private String name;
    private double salary;
    private Date hireDay;
    public Employee(String n, double s, int year, int month, int day)
    {
        name = n;
        salary = s;
        GregorianCalendar calendar = new GregorianCalendar(year,month - 1,day);
        hireDay = calendar.getTime();
    }
    public String getName()
    {
        return name;
    }
    public double getSalary()
    {
        return salary;
    }
    public Date getHireDay()
    {
        return hireDay;
    }
    public void raiseSalary(double byPercent)
    {
        double raise = salary * byPercent / 100;
        salary += raise;
    }
}

3.1 构造器

    public Employee(String n, double s, int year, int month, int day)
    {
        name = n;
        salary = s;
        GregorianCalendar calendar = new GregorianCalendar(year,month - 1,day);
        hireDay = calendar.getTime();
    }

构造器就是我们所说的构造方法，它与类同名。在构造Employee类的对象时被运行，以便将实例域初始化为希望的状态。例如：new Employee("tom",21000,1987,1,1);就可以将实例域设置为，name="tom";salary=21000;hireDay=January 1,1987; 如果编写一个类没有编写构造器，那么系统会提供一个默认构造器。这个构造器将所有的实例域设置为默认值。我们要记住构造器的特点：

1.构造器与类同名。2.每个类可以有一个或者一个以上的构造器。3.构造器可以有0个，1个或者1个以上的参数。4.构造器没有返回值。5.构造器总是伴随new操作一起调用。

3.2 隐式参数与显式参数

上例中raiseSalary方法中有两个参数，第一个是隐式参数，是出现在方法名前的Employee类对象。第二个参数是位于方法名后面的括号中的数值，这是一个显示参数，可以看到显式参数是明显的列在方法声明中的显示参数，e.g: double byPercent。隐式参数没有出现在方法声明中。

在每一个方法中，关键字this表示隐式参数也就是被构造的对象。如果需要的话我们还可以将raiseSalary方法这样书写：

    public void raiseSalary(double byPercent)
    {
        double raise = this.salary * byPercent /100;
        this.salary += raise;
    }

4. 包

Java允许使用包(package)将类组织起来，借助包可以方便的组织自己的代码，并将自己的代码和别人提供的代码库分开管理。对于上一个例子我在IDEA实现时就可以将主类和其它类放在同一个包中并分开实现，这样在实现一些类比较多的任务时，就可以很方便的找到要修改的一些类。

在IDEA中想实现将类放入包中，我们可以先建一个包，然后在包中新建源文件。

5. 类的导入

一个类可以使用所属包中的所有类，以及其他包中的公有类。有两种方式可以访问另一个包中的共有类，一种是在每个类名之前添加完整的包名，例如：java.util.Date today = new java.util.Date(); 但这明显不实用也不美观，因此我们采用第二种方式：使用import语句。例如我们想要导入util包中的所有类，就可以在开头这样写：import java.util.*;

举一个例子，假设我们需要从键盘输入一个字符串，并打印它，我们就需要导入Scanner类来从键盘获取信息。我们就可以这样：