三、对象与类

于 2020-04-28 13:25:39 发布
阅读量547 收藏
点赞数
分类专栏： java核心技术卷1 读书笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42270665/article/details/105811553
版权

1、面向对象程序设计概述

面向对象（OOP）是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。在OOP中，不必关心对象的具体实现，只要能满足用户的需求即可

在这里插入图片描述
类与对象概述：

类：是构造对象的模板或蓝图；由类构造对象的过程称为创建类的实例
封装：封装就是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式
对象：类的实例就是对象
类之间的关系：

  • 依赖（uses-a）：A中需要使用到B对象，那么AB是依赖关系 （实际开发中应尽量减少类之间的依赖关系）
  • 聚合（has-a）：A中包含B的对象，那么AB是聚合关系
  • 继承（is-a）：A扩展了B，A中不仅包含从B继承的方法，还有自己的方法，那么A继承于B

2、预定义类

eg: Date类 & Calender类

package com.java01.day02;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * @description: Date  Calender
 * @author: dajuweizhong
 * @date: 2020-04-28 13:54
 */
public class DateTest {
    public static void main(String[] args){
        Date date = new Date(); //当前时间
        long time = date.getTime();
        System.out.println(time); //1588053353775
        String s = date.toString();
        System.out.println(s); //Tue Apr 28 13:56:24 GMT+08:00 2020
        //比较date与当前时间  before:是否在当前时间之前  after：是否在当前时间之后
        boolean before = date.before(new Date());
        boolean after = date.after(new Date());
        System.out.println(before + "----" + after); //true----false

		//定义时间格式为：yyyy-MM-dd HH:mm:ss
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        //设置时间为 1998-04-07 13:59:59
        calendar.set(Calendar.YEAR, 1998); //年
        calendar.set(Calendar.MONTH, 3); //月 （+1）
        calendar.set(Calendar.DAY_OF_MONTH, 7); //日
        calendar.set(Calendar.HOUR_OF_DAY, 13); //时
        calendar.set(Calendar.MINUTE, 59); //分
        calendar.set(Calendar.SECOND, 59); //秒
        //Calendar转换为Date
        Date date1 = calendar.getTime();
        //将Date按时间格式转换为字符串
        String format = simpleDateFormat.format(date1);
        System.out.println(format); //1998-04-07 13:59:59
        //获取年月日...
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "-" + month + "-" + day); //1998-4-7
    }
}

3、自定义类

package com.java01.day02;

import java.util.Date;

/**
 * @description: 员工类
 * @author: dajuweizhong
 * @date: 2020-04-29 13:36
 */
public class Employee {
    //成员变量
    /**
     * 名字
     */
    private String name;
    /**
     * 年龄
     */
    private int age;
    /**
     * 生日
     */
    private Date birthDay;

    /**
     * 有参构造 
     * @param name 名字
     * @param age 年龄
     * @param birthDay 生日
     */
    public Employee(String name, int age, Date birthDay) {
        //对成员参数进行初始化
        this.name = name;
        this.age = age;
        this.birthDay = birthDay;
    }

    /**
     * 无参构造
     */
    public Employee(){

    }

    //成员变量对应的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;
    }

    public Date getBirthDay() {
        return birthDay;
    }

    public void setBirthDay(Date birthDay) {
        this.birthDay = birthDay;
    }
}

4、修饰关键字

4.1 public & private
 * public：公有，可以被其他的类操作调用
 * private：私有，只能在本类中使用，不会被外部的其他类调用操作
4.2 final
* final是常量修饰符，被final修饰的对象是不可变的
4.3 静态与非静态 static
 * static是静态修饰符，静态的成员变量、成员方法都是放在静态域中的，是随着类的创建而产生，所以使用类名.来调用，也可以使用对象.调用；
 * 静态方法中只能调用静态方法或静态的成员变量；
 * 静态成员变量、静态方法被该类的所有实例化对象所共享；
 * 静态方法还有一个常见用途：工厂方法
   eg:
   NumberFormat format = NumberFormat.getCurrencyInstance();
   NumberFormat numberFormat = NumberFormat.getPercentInstance();
   Double x = 0.1;
   System.out.println(format.format(x)); //￥0.10
   System.out.println(numberFormat.format(x)); //10%
 
 * 而非静态的成员变量、成员方法都是放在栈内存中的，是随着对象的创建而产生，所以只能使用对象.调用

package com.java01.day02;

import java.text.NumberFormat;

/**
 * @description:  private public static final 
 * @author: dajuweizhong
 * @date: 2020-04-29 13:51
 */
public class StaticFinalDemo {
    
    //用private修饰，是私有的，只能在本类中使用
    private static final String STATIC_FINAL_STRING = "static final String";
    private static String staticString = "static String";
    private final String FINAL_STRING = "final String";
    private String string = "string";

    //用public修饰，是公有的，可以在别的类通过对象名.调用
    public void test(){
        //用static修饰，是静态的，可以使用类名.调用，也可以使用对象名.调用
        //用final修饰，是常量，不可改变
        System.out.println(StaticFinalDemo.STATIC_FINAL_STRING);
        System.out.println(StaticFinalDemo.staticString);
        StaticFinalDemo demo = new StaticFinalDemo();
        //非静态的只能通过对象名.调用
        System.out.println(demo.FINAL_STRING);
        System.out.println(demo.string);
    }

    public static void main(String[] args){
        NumberFormat format = NumberFormat.getCurrencyInstance();
        NumberFormat numberFormat = NumberFormat.getPercentInstance();
        Double x = 0.1;
        System.out.println(format.format(x)); //￥0.10
        System.out.println(numberFormat.format(x)); //10%
    }
}

5、方法参数

java程序设计语言总是采用按值调用
java程序设计对对象采用的不是引用调用，实际上，对象引用采用的是值传递

  • 一个方法不能修改一个基本数据类型的参数（即数值型和布尔型）
  • 一个方法可以改变一个对象参数的状态
  • 一个方法不能让对象参数引用一个新的对象

在这里插入图片描述

package com.java01.day02;

import java.util.Date;

/**
 * @description: java程序设计语言总是采用按值调用
 * java程序设计对对象采用的不是引用调用，实际上，对象引用采用的是值传递
 * @author: 周婷 ting.zhou@luckincoffee.com
 * @date: 2020-04-29 14:16
 */
public class Test {
    public static void main(String[] args){
        int x = 10;
        // 一个方法不能修改一个基本数据类型的参数（即数值型和布尔型）
        mul(x);
        System.out.println(x); //10

        Employee employee1 = new Employee("lisi", 24, new Date());
        Employee employee2 = new Employee("zhangsan", 17, new Date());
        //一个方法可以改变一个对象参数的状态
        changeAge(employee1);
        System.out.println(employee1.getAge()); //10000
        //一个方法不能让对象参数引用一个新的对象
        swap(employee1, employee2);
        System.out.println(employee1.getName()); //lisi
        System.out.println(employee2.getName()); //zhangsan
    }

    private static void mul(int x){
        x = x * 3;
    }

    private static void changeAge(Employee employee1){
        employee1.setAge(10000);
    }

    private static void swap(Employee employee1, Employee employee2){
        Employee employee = employee1;
        employee1 = employee2;
        employee2 = employee;
    }
}

6、对象构造

 * 1、重载：重载指多个方法的方法名相同，而参数却不同（不考虑返回值是否相同）
 * 2、默认域初始化：如果在构造器中没有显式地给域赋予初值，那么就会被自动的被赋予默认值，
 * 数值为0，布尔值为false，对象引用为null
 * 3、无参数的构造器：如果在编写一个类时没有编写构造器，那么系统就会提供一个无参构造器，
 * 这个构造器将所有的实例域设置为默认值
 * 如果类中提供了至少一种构造器，但是没有提供无参构造器，则系统不会默认提供一个无参构造器，
 * 所以建议还是如果写了构造器，就尽量把无参构造也写上。
 * 4、调用另一个构造器：用this(...)调用另一个构造器
 * 5、finalize方法：当某些对象使用了内存之外的其他资源，例如：文件；
 * 在这种情况下，当资源不再需要时，就可以通过finalize方法将其回收

package com.java01.day02;

import java.util.Date;

/**
 * @description: 对象构造
 * @author: dajuweizhong
 * @date: 2020-04-29 15:43
 */
public class Demo02 {
    /**
     * 对象构造
     * 1、重载：重载指多个方法的方法名相同，而参数却不同（不考虑返回值是否相同）
     * 2、默认域初始化：如果在构造器中没有显式地给域赋予初值，那么就会被自动的被赋予默认值，
     * 数值为0，布尔值为false，对象引用为null
     * 3、无参数的构造器：如果在编写一个类时没有编写构造器，那么系统就会提供一个无参构造器，
     * 这个构造器将所有的实例域设置为默认值
     * 如果类中提供了至少一种构造器，但是没有提供无参构造器，则系统不会默认提供一个无参构造器，
     * 所以建议还是如果写了构造器，就尽量把无参构造也写上。
     * 4、调用另一个构造器：用this(...)调用另一个构造器
     * 5、finalize方法：当某些对象使用了内存之外的其他资源，例如：文件；
     * 在这种情况下，当资源不再需要时，就可以通过finalize方法将其回收
     */

    private Long id;
    private String name;

    /**
     * 空参构造
     */
    public Demo02(){

    }

    /**
     * 有参构造
     * @param id id
     * @param name name
     */
    public Demo02(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Demo02(String name){
        this.name = name;
    }

    /**
     * 调用另一个构造器
     * @param id id
     */
    public Demo02(Long id){
        this("张三");
        this.id = id;
    }

    /**
     * 重载方法method
     */
    private static void method(String str){
        System.out.println(str);
    }

    private static void method(Employee employee){
        System.out.println(employee.getName() + "--" + employee.getAge());
    }

    public static void main(String[] args){
        method("入参为String的method"); //入参为String的method
        Employee employee = new Employee("张三", 13, new Date());
        method(employee); //张三--13
    }
}
大橘为重yo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值