Java教程

2.面向对象基础-01Java类和对象

本文主要是介绍2.面向对象基础-01Java类和对象,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

写在前面:

(1)编程语言的发展(人越来越容易理解):

  机器语言

  汇编语言

  高级语言-面向过程

  高级语言-面向对象

(2)面向对象的特点:

  封装性

  继承性

  多态性

01Java类和对象

  对象:属性(静态特征、数据)和行为(动态特征、方法)

  类:具有相同属性的行为的对象的抽象

  java中,万物皆可对象

 

 

 

一、Java类

  组成:数据成员和方法成员

    -数据成员(成员数据、变量、属性、字段):类/对象的属性-静态

    -方法成员(成员方法、过程、函数):类/对象的操作-动态

  例子:product类

public class Product 
{
    //数据成员
    public String name;
    public double price;
    public int storage ;
    public double cost;//成本
    public double discount = 1;
    public double capital = 1000000;//总资金
    public double profit = 0;//利润
    //构造函数
    public Product(String name, double price, int storage,double cost) {
        this.name = name;
        this.price = price;
        this.storage = storage;
        this.cost = cost;
    }
    //方法成员
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getStorage() {
        return storage;
    }
    public void setStorage(int storage) {
        this.storage = storage;
    }
    public double getDiscount() {
        return discount;
    }
    public void setDiscount(double discount) {
        this.discount = discount;
    }
    public double getCost() {
        return cost;
    }
    public void setCost(double cost) {
        this.cost = cost;
    }
    public double getCapital() {
        return capital;
    }
    public void setCapital(double capital) {
        this.capital = capital;
    }
    public double getProfit() {
        return profit;
    }
    public void setProfit(double profit) {
        this.profit = profit;
    }
    
    public void purchase(int num)
    {
        this.storage -= num;
        double profit1 = num*(price-cost);
        profit += profit1;
        capital += profit1;
    }
    public void addStorage(int num)
    {
        capital -= num*cost;
        if(capital < 0)
        {
            System.out.println("破产了!!!!!!!!");
        }
        this.storage += num;
    }
    public void applyDiscount(double discount)
    {
        if(discount >= 1)
        {
            discount = 1;
        }
        this.price = price*discount;
    }
    public void printInfo()
    {
        System.out.println("name : "+name);
        System.out.println("price : "+price);
        System.out.println("storage : "+storage);
        System.out.println("capital : "+capital);
        System.out.println("profit : "+profit);
        
    }
    
}

Main函数

import java.util.Scanner;
public class Main 
{
    public static void main(String[] args)
    {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入产品名:");
        String name = s.next();
        System.out.println("请输入价格:");
        double price = s.nextDouble();
        System.out.println("请输入库存:");
        int storage = s.nextInt();
        System.out.println("请输入成本价:");
        double cost = s.nextDouble();
        Product p = new Product(name,price,storage,cost);
        System.out.println("请输入折扣:");
        p.applyDiscount(s.nextDouble());
        p.printInfo();
        System.out.println("请输入购买量:");
        p.purchase(s.nextInt());
        p.printInfo();
        System.out.println("请输入进货量:");
        p.addStorage(s.nextInt());
        p.printInfo();
        s.close();
    }
}

 

二、对象

  类和对象的关系:类是对象的类型,对象是类的实例

    创建对象

    适用对象

(一)对象创建和使用

  1.使用new创建新的对象:类名 对象变量名 = new 类名([参数]);

  2.对象变量.成员变量:访问对象的成员变量

  3.对象变量.方法(实参列表):调用对象的方法

  4.类占用内存:基加成员的占用,Object成员只记引用

(二)访问权限控制

  1.对不同类之间进行类、类的属性(数据)、类的方法(函数)的访问进行权限控制

 

   一般情况下,方法为public,数据为private。方法提供了访问一个对象的数据的对外接口,体现了对数据的保护。

  2.类与对象

    (1)类(商品)

      定义了所有商品的属性和行为

      是一种类型,用来定义变量

      表示一种静态概念,不占用内存

    (2)对象(这件商品)

      表达具体的实体

      运行时占用内存(属性),进行信息交互(操作)

    (3)把数据和对数据的操作放在一起,形成类->封装

      封装性 是面向对象程序的三大特征之一

  3.Java引用变量

    引用类型:java中除了基本类型以外的变量类型都是引用类型

    作用:通过引用操作对象,对象的管理者

      Product p = new Product();

     p:对象变量(引用)

     

 

 

     对象变量为空:null

  4.Java内存空间分配

    

 

   (1)方法执行有其内存栈,所有本地变量(包括形参)按顺序压入栈中(先进后出)

    -方法执行结束时其内存栈也将自然摧毁

   (2)创建对象时,该对象被保存在堆(运行时数据区)中,以便反复利用(创建对象成本较大)

    ①堆内存中的对象不会随方法的结束而摧毁(即使方法结束后,该对象还可能被引用)

    ②当对象还没有被引用时,系统会在合适的时候收回它

 

 5.时间类

public class MyTime 
{
    public int hour;
    public int minute;
    public int second;
    public MyTime(int hour, int minute, int second) 
    {
        this.hour = hour;
        this.minute = minute;
        this.second = second;
    }
    public int getHour() {
        return hour;
    }
    public void setHour(int hour) {
        this.hour = hour;
    }
    public int getMinute() {
        return minute;
    }
    public void setMinute(int minute) {
        this.minute = minute;
    }
    public int getSecond() {
        return second;
    }
    public void setSecond(int second) {
        this.second = second;
    }
    
    public void before(MyTime t)
    {
        this.hour -= t.hour;
        this.minute -= t.minute;
        this.second -= t.second;
    }
    public void after(MyTime t)
    {
        this.hour += t.hour;
        this.minute += t.minute;
        this.second += t.second;
    }
    
    public void print()
    {
        System.out.printf("%02d:",this.hour);
        System.out.printf("%02d:",this.minute);
        System.out.printf("%02d",this.second);
    }
    
}

Main函数

import java.util.*;
public class Main 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        int hour = s.nextInt();
        int munite = s.nextInt();
        int second = s.nextInt();
        MyTime mt = new MyTime(hour,munite,second);
        mt.print();
        int hour1 = s.nextInt();
        int munite1 = s.nextInt();
        int second1 = s.nextInt();
        MyTime mt1 = new MyTime(hour1,munite1,second1);
        mt.before(mt1);
        mt.print();
        int hour2 = s.nextInt();
        int munite2 = s.nextInt();
        int second2 = s.nextInt();
        MyTime mt2 = new MyTime(hour2,munite2,second2);
        mt.after(mt2);
        mt.print();
        s.close();
    }
}

6.思考总结

思考

(1)Java中的值传递方式:JAVA中没有引用传递, 全部是按值调用

  ①函数为什么能修改真实的对象呢?这不是引用传递的特征吗?

      引用传递指针时, 连函数操作的指针都是原来的指针,比如C++传入对象时直接用传入的指针操作

      而JAVA的引用传进函数时 , 会复制一个引用与实参指向同一对象的引用, 操作的不是同一个引用,

    详见:https://blog.csdn.net/q5706503/article/details/82910428

(2)Java中对象的赋值是深拷贝还是浅拷贝

    详见:https://blog.csdn.net/liutaiyi8/article/details/108980650

(3)Java中对象的比较,如”==“比较的是对象的内存地址

总结

(1)引用类型变量存放在栈内存中;对象通过new产生,位于堆内存

(2)同一个类的每个对象占用不同的成员变量存储空间,每个成员变量在不同的对象中可以有不同的值(静态变量除外)

(3)方法仅一份,存放在代码区,执行时再分配内存。同一类的每个对象共享该类的代码。

三、Java类的生命周期

四、this引用

五、static变量

这篇关于2.面向对象基础-01Java类和对象的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!