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变量
标签：对象,double,void,System,01Java,面向对象,int,public 来源： https://www.cnblogs.com/Chenury/p/14946633.html