day6.1 对象和类

package practise;
//面向对象 三大特征 1.封装性 2.继承性 3.多态（最为重要，增加软件的灵活性和重用性）

	//类 和 对象 
	//计算机语言用来描述现实世界的事物，Java语言的最小单位是类，Java通过 用类来抽象现实世界的事物的共同特征和行为，相当于一个抽象的模板
	//而对象，则是对类的具体化
	//举个例子   手机  作为一个类  ，它包含一些抽象的特征：型号，价格，品牌等   也包含一些抽象的行为：打电话，发短信等
	// 而其对象可以根据这个手机类，作为一个模板，进行具体化   如对象1  型号：v8， 价格1000， 品牌：华为    对象2  型号 6s ，价格 2000，品牌 苹果
	//Java语言中 ，通过类来描述事物，把事物的属性当作成员变量，把事物的行为当作成员方法
	
	//类的创建和使用

public class duixiang { //一个Java文件中，可以有多个类，但是只能由一个public类，并且public类的类名要和Java的文件名字相同

public static void main(String[] args) { 

// phone p = new phone(); //通过关键字new 来创建对象 此时p是引用类型phone的变量（局部变量），它引用（被赋值为phone在内存中的地址）phone在内存中的地址
// p.call(); //此时p已代表phone，能够直接调用其成员变量和成员方法
// p.pinpai = “华为”; //调用phone的成员变量并赋值
//输出结果：打电话 //调用步骤 首先通过对象在p中存着的地址，找到对象在堆中的位置，然后寻找对象中相应的成员变量或方法，如果对象中没有，却调用的话则报错

// car c = new car();
// c.pinpai =“bmw”;
// c.price =99999;
// c.weight =999.12;
//
// c.runing();
// c.stop();
//
// System.out.println(c.pinpai);
// System.out.println(c.price);
// System.out.println(c.weight);
//结果：正在行驶
// 正在停车
// bmw
// 99999
// 999.12

	//对象在内存中的存储
	//一般，局部变量存储在栈中（后进先出），等局部变量所在的方法执行结束后，局部变量所占空间将被释放
	//对象（new 出来的东西）在被创建后，存储在堆当中（没有规则），直到对象不再被使用后，所占内存才会被释放。
	//每个堆内存的元素都有默认值，即对象的属性（成员变量）都有默认值
	
	//car c = new car(); //这一步在内存中进行的反应
	                     //1. 在栈内存中开辟空间，把p压入栈中（分配内存）
	                     //2. 在堆内存中开辟空间，存放对象
	                     //3. 将对象的属性进行初始化
	                     //4. 为对象分配一个唯一的地址
	                     //5. 将地址赋值给引用型变量 p保存
	
	
	//创建多个对象  即同一个模板（类），可以产生多个对象

// phone p2 =new phone(); //同p，同为引用类型phone 的变量，也可以调用class phone的成员变量和方法
// p2.pinpai =“小米”;
// p2.price =888;
// p2.xinghao =“6s”;
//
// p2.call();
// p2.message();
// System.out.println(p2.pinpai);
// System.out.println(p2.price);
// System.out.println(p2.xinghao);
//
//结果：打电话
// 发短信
// 小米
// 888
// 6s

// phone p3 = p2; //p3同为引用型变量phone的变量，但是这里没有new ,即没有在栈中开辟新的空间，只是保存了p2所保存的内容，即phone的地址值
// System.out.println(p3.pinpai);
// System.out.println(p3.price);
// System.out.println(p3.xinghao);
// p3.call();
// p3.message();
//结果 可以看到与p2完全相同
// 小米
// 888
// 6s
// 打电话
// 发短信

	//封装 指的是隐藏对象的属性和方法  目的：提高安全性和重用性
	//private（私有） 关键字  权限修饰符 用于修饰成员变量或者是成员方法  能够进行封装  只能被其所在类访问
	//public（公共） 关键字 相对于private 其所修饰的成员变量和成员方法，能够被Java文件中的所有类进行访问
	
	//练习 封装学生 
	
	student s =new student();

// System.out.println(s.age); //报错，因为此时age已经被封装，除student类之外，其它所有类都无法访问
System.out.println(s.id); //输出为0 ，为其默认值

	s.eat();                  

// s.study(); //同理，报错

	//那么如何访问被private修饰的成员变量呢？ -- 在其所在的类中建立公共的set（）方法为成员变量进行赋值，建立公共的get（）方法，来获取其值
	
	s.setAge(10);  //对封装变量age进行赋值10
	int a =s.getAge(); //获取封装变量age的值，此时已不再是默认值，而是10
	System.out.println(a); //结果为10
	
	//那么如何访问被private修饰的成员方法呢？ --  在其所在类的其它公共的方法中调用它
	
	s.sleep(); //输出结果为 学习 睡觉

			
	s.setHeight(10.8);
	System.out.println(s.getHeight());  //输出结果为 10.8
	
	
	
}

}
class student {
private int age ; //对成员变量 age 进行封装，使其只能在student类中能够被访问
int id;
private String name;
private double height;

//自动生成代码，右键 - source -generate setters and getters - select all-ok   快速生成被封装成员变量的 set（）方法和get()方法
public double getHeight() {   //为自动生成
	return height;
}
public void setHeight(double height) {   //为自动生成
	this.height = height;    //this 的作用后面学
}


public void setAge(int n) {   //设置公共方法，来为被封装的成员变量进行赋值
	age = n;
}

public int getAge() {  //设置公共方法，来获取被封装的成员变量的值
	return age;
}

public void sleep() {
	study();                    //调用封装成员方法 study（）
	System.out.println("睡觉");
}


public void eat() {
	System.out.println("吃饭");
}
private void study(){
	System.out.println("学习");
}

}

class phone { //和public类同等级 格式 class 类名 { }
//事物的特征 – 成员变量/成员属性
String xinghao; //此时为成员变量（类中，方法外），具有默认值，不需要进行初始化
int price;
String pinpai;

//事物的行为 -- 成员方法/成员函数
public void call() {
	System.out.println("打电话");
}
public void message() {
	System.out.println("发短信");
}

}

class car{ //练习：定义car类
int price;
String pinpai;
double weight;

public void runing() {
	System.out.println("正在行驶");
}
public void stop() {
	System.out.println("正在停车");
}

}