1、类与对象的关系
类相当于抽象的概念
对象是类的具体表现
如何用java语言描述现实世界的事物呢？
举例：人
五官，姓名，年龄，性别....
吃饭，学习，说话....
水杯：
颜色，材质，形状，容积...
装水，泡茶...
属性：用于描述事物的信息
行为：用来描述事物能够做什么的
我们学习编程语言，目的其实用来描述现实世界的事物
而我们现在所学的语言：java
现在就要开始学习如何用java来描述一个现实世界的事物
首先，我们知道java的最基本的单位是：类
所以我们应该通过java中的类去描述现实世界的事物
按照我们分析现实事物的角度出发得到一个与java中类的对应关系
现实事物： 类：
属性：用于描述事物的信息 成员变量：用于描述事物的信息
行为：用来描述事物能够做什么的 成员方法：用来描述事物能够做什么的
类：是一组成员变量和成员方法的集合，可以把类看作一个抽象的概念
对象：是该类的具体的表现，具体到一个个体
举例：
事物：人
属性：姓名，性别，年龄...
行为：吃饭，睡觉，学习...
类：Person
成员变量：name,gender,age
成员方法：eat(),sleep(),study()
对象：是该类的具体的表现，具体到一个个体
学生，老师，医生，律师，程序员
============================================================
2、定义一个类：
成员变量：
成员方法：
如何创建对象：
类名 对象名 = new 类名()
通过对象访问成员变量：对象名.非私有的成员变量名
通过对象访问成员变量：对象名.非私有的成员方法
============================================================
/*
事物：
属性：用来描述事物的信息
行为：用来描述事物能够做什么
类：
成员变量：事物的属性
成员方法：事物行为
定义一个类，其实就是定义这个类中成员变量和成员方法。
案例：我们来完成一个学生类的定义
学生：
属性：姓名，性别，年龄
行为：学习，吃饭，睡觉
类：
成员变量：name,gender,age
成员方法：study(),eat(),sleep()
如何定义一个成员变量？
1、定义的位置：在类中，方法外
2、定义的格式：
数据类型 变量名;
如何定义一个成员方法？
1、定义的位置：在类中
2、定义的格式：
修饰符 返回值类型 方法名(参数列表){
方法体;
}
我们之前教大家定义修饰符的时候，使用public static
而现在，由于我们还没有学过static的作用，现在先去掉static,现在只用public,直到学到了static，我们在加上
*/
public class Demo {
}
============================================================
/*
定义一个学生类，完成类的成员（成员变量和成员方法）
在一个java文件可以定义多个类，我们这里，就先定义基本的类，和测试类
将来编译的时候，JVM会读取java文件，有多少个class类，就编译生成多少个.class文件
注意事项：一个java文件中只能有一个类被public修饰
只需要记住被public修饰的类规范是要与java文件名一致
如何在测试类中使用学生类呢？
创建该类的对象去使用
如何创建对象呢？创建对象的格式是什么呢？
类名 对象名称 = new 类名(..);
*/
//这是一个学生类，类是java最基本的单位
public class Student {
//成员变量
//姓名
String name;
//性别
String gender;
//年龄
int age;
//定义成员方法
//学习
public void study(){
System.out.println("我热爱学习大数据");
}
//吃饭
public void eat(){
System.out.println("学习饿了，吃会东西");
}
//睡觉
public void sleep(){
System.out.println("学习类，睡一会觉");
}
}
class StudentTest{
public static void main(String[] args) {
// System.out.println("HelloWorld");
//如果不创建对象能不能使用呢？（指的是能否访问到成员变量或者成员方法）
// System.out.println(name);
//创建一个学生对象才能使用
Student s1 = new Student();
//这样我们就创建出一个学生对象s1
//如何通过对象访问成员变量呢？
//访问格式：对象名.成员变量名
//访问s1对象的姓名是什么
// s1.name; //访问到的变量值不能直接使用，应该用一个变量接收或者直接使用输出
System.out.println(s1.name); //null
System.out.println(s1.gender); //null
System.out.println(s1.age); //0
//如何给成员变量赋值
s1.name = "王宇";
s1.gender = "男";
// s1.age = "明旺 "; //注意，赋值的时候，注意数据类型
s1.age = 18;
System.out.println(s1.name);
System.out.println(s1.gender);
System.out.println(s1.age);
//如何去调用成员方法呢？
//调用格式：对象名.成员方法名(...);
s1.study();
s1.eat();
s1.sleep();
}
}
============================================================
/*
定义一个手机类：
属性：品牌，价格，颜色
行为：打电话，发信息，听音乐
定义一个类：Phone
成员变量：brand,price,color
成员方法：call(String s),sendMessage(),listenMusic()
*/
class Phone{
//定义成员变量
String brand;
int price;
String color;
//成员方法
public void call(String s){
System.out.println("打电话给"+s);
}
public void sendMessage(){
System.out.println("发信息");
}
public void listenMusic(){
System.out.println("听音乐");
}
}
public class PhoneTest {
public static void main(String[] args) {
//根据手机类创建一个手机对象
Phone p1 = new Phone();
//通过创建出来的手机对象访问对象成员变量
//创建对象另外一种说法：实例化
System.out.println(p1.brand); //null
System.out.println(p1.price); //0
System.out.println(p1.color); //null
//给对象的成员变量进行赋值
p1.brand = "华为";
p1.price = 9999;
p1.color = "曜石黑";
System.out.println("手机的品牌是："+p1.brand);
System.out.println("手机的价格是："+p1.price);
System.out.println("手机的颜色是："+p1.color);
//通过对象调用成员方法
p1.call("杨老板"); //注意，调用对象的成员方法的时候，需要注意是否要传参！
p1.sendMessage();
p1.listenMusic();
}
}
============================================================
/*
创建两个对象并赋值调用
*/
//同一个包下，类名不能重复
class Phone1{
//成员变量
String brand;
int price;
String color;
//成员方法
public void call(String s){
System.out.println("打电话给"+s);
}
public void sendMessage(){
System.out.println("发信息");
}
public void listenMusic(){
System.out.println("听音乐");
}
}
public class PhoneTest2 {
public static void main(String[] args) {
//定义一个手机类
Phone1 p1 = new Phone1();
//给手机对象p1成员变量赋值
p1.brand = "小米";
p1.price = 1999;
p1.color = "白色";
System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
p1.call("雷军");
p1.sendMessage();
p1.listenMusic();
//定义第二个手机对象
Phone1 p2 = new Phone1();
p2.brand = "苹果";
p2.price = 4999;
p2.color = "黑色";
System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
p2.call("乔布斯");
p2.sendMessage();
p2.listenMusic();
}
}
============================================================
/*
3个对象的内存图
其中有两个引用指向同一个对象
*/
class Phone3{
//成员变量
String brand;
int price;
String color;
//成员方法
public void call(String s){
System.out.println("打电话给"+s);
}
public void sendMessage(){
System.out.println("发信息");
}
public void listenMusic(){
System.out.println("听音乐");
}
}
public class PhoneTest3 {
public static void main(String[] args) {
//定义一个手机类
Phone3 p1 = new Phone3();
//给手机对象p1成员变量赋值
p1.brand = "小米";
p1.price = 1999;
p1.color = "白色";
System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
p1.call("雷军");
p1.sendMessage();
p1.listenMusic();
//定义第二个手机对象
Phone3 p2 = new Phone3();
p2.brand = "苹果";
p2.price = 4999;
p2.color = "黑色";
System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
p2.call("乔布斯");
p2.sendMessage();
p2.listenMusic();
//创建第三个手机对象，将第一个对象名赋值给它
Phone3 p3 = p1;
p3.brand = "华为";
p3.price = 19999;
p3.color = "蓝色";
System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
}
}
============================================================
3、成员变量与局部变量的区别
/*
成员变量与局部变量的区别：
1、在类中定义的位置不同
成员变量：类中，但是在方法外
局部变量：定义在方法内部
2、在内存中的位置也不同
成员变量：在堆内存中
局部变量：在栈内存中
3、初始化值也不同
成员变量：系统会给予默认值
局部变量：没有系统给的默认值，必须在定义的时候赋值，亦或者在方法中使用之前赋值，然后才能使用。
4、生命周期不同
成员变量的生命周期：随着对象的创建而创建，随着对象的消失而消失
局部变量的生命周期：随着方法的调用而创建，随着方法的调用完毕而消失
注意事项：
1、局部变量的名字可以和成员变量的名字一样，在方法中使用的时候，采用就近原则
方法中使用的变量，会现在方法内部查找，如果方法内部没有，去成员变量中查找。
2、方法与方法之间里面的局部变量变量，不能互相调用。
*/
class BianLiang{
String name;
int age;
public void show(int n){
n = 10;
int a = 20;
// int b;
// System.out.println(b);
System.out.println(n);
System.out.println(a);
String name = "王宇";
System.out.println(name);
}
// public void show2(){
// System.out.println(a);
// }
}
public class BianLiangDemo {
public static void main(String[] args) {
//成员变量的使用，需要创建对象（最起码这里是要创建对象才能使用的）
BianLiang b1 = new BianLiang();
b1.name = "明旺";
System.out.println(b1.name);
b1.show(100);
}
}
============================================================
4、 形式参数问题
/*
形式参数的问题：
1、当形式参数是基本数据类型的时候,将来调用方法的时候传入的是常量值,或者是该类型的变量
2、当形式参数是引用数据类型的时候，将来调用方法的时候传入的是该类对象的地址值
3、当形式参数是基本数据类型的时候，在方法中对变量做修改，不会影响到外部实际的栈内存中的值。
4、当形式参数是引用数据类型的时候，在方法中对变量做修改，会影响到外部实际的堆内存中的值。
*/
class Demo2 {
public int getSum(int a,int b) {
a=100;
b=200;
return a + b;
}
}
class Student2{
String name;
public void speak(){
System.out.println("我热爱学习");
}
}
class StudentTest2{
/**
* 如果将来你看到一个方法的形式参数是一个类的类型，说明他是一个引用数据类型
* 这里其实需要的是该类的对象
* 调用的时候，把main方法中创建好的对象名传过来，实际上传的就是对象的地址值
* @param s
*/
public void function(Student2 s){ //Student2 s = new Student2();
s.name = "小王";
s.speak();
}
}
public class XingShiCanShuDemo {
public static void main(String[] args) {
Demo2 d = new Demo2();
int a = 10;
int b = 20;
System.out.println(d.getSum(a,b));
System.out.println("a:"+a+",b:"+b);
//要想调用function(),就必须创建StudentTest2对象
StudentTest2 st2 = new StudentTest2();
Student2 student2 = new Student2();
System.out.println(student2.name);
st2.function(student2);
System.out.println(student2.name);
}
}
============================================================
5、匿名对象
/*
匿名对象：就是没有名字对象
匿名对象的使用场景：
1、调用方法的时候，仅仅调用一次的时候，可以使用匿名对象
注意，当调用多次的时候，不适合,每次new的时候都是一个新的匿名对象，会频繁的在堆内存中开辟空间
当匿名对象使用完毕之后，无法再使用第二次，就变成了一个垃圾（当栈中没有变量引用它的时候，判定是一个垃圾），等待被垃圾回收器回收。
2、当方法的参数类型是一个类的时候，可以使用匿名对象调用方法。
*/
class Phone4{
public void show(){
System.out.println("手机可以打电话");
}
}
class PhoneDemo{
public void function(Phone4 p){
p.show();
}
}
public class AnonymousDemo {
public static void main(String[] args) {
//创建一个PhoneDemo对象
PhoneDemo pd = new PhoneDemo();
Phone4 phone = new Phone4();
pd.function(phone);
System.out.println("=============================");
//当new完对象之后直接使用，没有用变量名接收的对象，称之为匿名对象
new PhoneDemo().function(new Phone4());
new PhoneDemo().function(new Phone4());
}
}
============================================================
6、private关键字：
私有的。它可以修饰成员变量和成员方法
被private修饰的成员只能在本类中进行访问。
/*
我们在定义一个学生类并使用的时候，发现了一个问题：
通过对象给成员变量赋值的时候，可以赋值一些非法的数据。
这样是不合理不符合现实生活的。
我们应该在赋值之前，做一次判断，数据校验，也就是对即将要赋值的数据做判断。
问题又来了，我们应该在哪里定义这个判断逻辑呢？
StudentDemo2是一个测试类，一般情况下，测试类负责创建对象并使用对象的地方，在这里定义判断逻辑是不合适的。
所以我们这里应该定义在Student3类中。
又因为，我们在定义成员变量的时候无法加入逻辑判断。
所以，我们在成员方法中定义。
因为做数据判断的时候，加的是一些逻辑判断语句，肯定不是只有一条。
我们应该在Student3类中提供一个方法来数据校验。
按照我们的想法，在类中提供了一个数值校验的方法，如果符合就成功赋值，反之则不赋值。
但是，谁规定了我定义了方法就一定会被使用呢，如果我还是用之前的获取成员变量的方式进行赋值，问题依旧存在
那么我们给出的方法意义就不是很大了。
实际上，我们应该定义了一个方法后，让调用必须使用我们的方法进行赋值，并且不能让调用者直接获取到我们成员变量。
怎么去强制要求不直接获取成员变量呢？
针对这样的情况，java就提供了一个关键字：private
private： 私有的。
其实说到现在，就是为了引出一个思想：封装
封装：其实就是隐藏对象的属性和相关的实现细节，仅仅对外提供公共的访问方式
*/
class Student3 {
//定义成员变量
String name;
private int age;
public void setAge(int a){
if(a200){
System.out.println("您要传入的年龄数据有误，请重新赋值");
}else{
age = a;
}
}
//定义一个输出所有的成员变量
public void show() {
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
}
}
public class StudentDemo2 {
public static void main(String[] args) {
//创建一个学生对象
Student3 s = new Student3();
s.show();
//给对象的成员变量赋值
s.name = "王宇";
// s.age = 18;
// s.age = 10000;
// s.setAge(10000);
//age 在 com.shujia.wyh.day08.Student3 中是 private 访问控制
// s.age = 10000; //由于我们在Student3类中name前面加了一个private关键字，不可以直接使用获取到成员变量，要想赋值，
//就必须使用我们提供的数据校验赋值方法
s.setAge(10000);
s.show();
}
}
============================================================
/*
获取成员变量值的方法：
1、提供一个公共的方法，打印所有的成员变量值
2、单个使用公共的获取方法，一个一个获取打印（开发）
原因：单个使用比一起使用的灵活度要高。
private : 私有的。
1、它可以修饰成员（成员变量和成员方法）
2、被private修饰的成员只能在本类中访问使用。其他类中使用不了
*/
class Person {
//private修饰成员变量
private String name;
private int age;
//提供一个公共set方法
public void setName(String s) {
name = s;
}
public void setAge(int a) {
age = a;
}
//提供一个公共的get方法，让外界获取到成员变量值
public String getName() {
return name;
}
public int getAge() {
return age;
}
//打印所有的成员变量值
private void show() {
System.out.println("姓名：" + name + ",年龄：" + age);
}
public void show2(){
show();
}
}
public class PrivateDemo1 {
public static void main(String[] args) {
Person p = new Person();
// System.out.println();
//调用公共的方法为成员变量进行赋值
p.setName("小明");
p.setAge(18);
// p.show();
p.show2();
//调用公共的方法获取成员变量的值
String name = p.getName();
System.out.println(name);
int age = p.getAge();
System.out.println(age);
}
}
============================================================
7、面向对象的三大特质之一：封装
隐藏类的属性和相关描述信息，仅提供公共get和set方法
============================================================
/*
规范定义一个类的标准版本1.0
1、将成员变量使用private修饰
2、提供公共getXxx()和setXxx()
3、提供一个方法打印所有的成员变量值（先自己定义，后面我们会学习新的方法替代）
*/
public class Teacher {
//定义成员变量
private String name;
private int age;
//提供公共的getXxx()和setXxx()方法
public void setName(String s) {
name = s;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge(){
return age;
}
//提供一个方法打印所有的成员变量值
public void show() {
System.out.println("姓名：" + name + ",年龄：" + age);
}
}
class TeacherTest{
public static void main(String[] args){
//创建一个老师对象
Teacher t1 = new Teacher();
//使用成员变量
//不能直接获取，因为它们都被private修饰了
// System.out.println(t1.name+"---"+t1.age);
//通过公共的方法来获取成员变量
System.out.println(t1.getName()+"---"+t1.getAge());
//给成员变量赋值
t1.setName("刘志城");
t1.setAge(18);
System.out.println(t1.getName()+"---"+t1.getAge());
t1.show();
}
}
============================================================
5、标准类的写法：
成员变量：被private修饰
成员方法：getXxx()和setXxx(),show()
============================================================
*
练习：请把手机类写成一个标准类的格式，然后创建对象并测试
手机类：
成员变量：
品牌：String brand;
价格：int price;
颜色：String color;
成员方法：
提供公共的getXxx()和setXxx()
提供一个方法查看手机详情
测试类：
创建手机对象并测试（给成员变量赋值，取值）
*/
class Phone2 {
//定义成员变量
private String brand;
private int price;
private String color;
//提供公共的getXxx()和setXxx()方法
public void setBrand(String s) {
brand = s;
}
public String getBrand() {
return brand;
}
public void setPrice(int p) {
price = p;
}
public int getPrice() {
return price;
}
public void setColor(String s) {
color = s;
}
public String getColor() {
return color;
}
//提供一个公共的方法打印手机详情
public void show() {
System.out.println("品牌：" + brand + ",价格：" + price + ",颜色：" + color);
}
}
public class PrivateTest {
public static void main(String[] args) {
//创建一个手机对象
Phone2 p = new Phone2();
//给成员变量进行赋值
p.setBrand("小米");
p.setPrice(2999);
p.setColor("黑色");
//获取成员变量并打印
//获取手机品牌
String brand = p.getBrand();
//获取手机对象p的价格
int price = p.getPrice();
//获取手机对象p的颜色
String color = p.getColor();
System.out.println("品牌：" + brand + ",价格：" + price + ",颜色：" + color);
//调用方法打印所有的成员变量值
p.show();
}
}
============================================================
8、this关键字
this代表的是将来调用该方法的对象。进而得到标准类写法2.0版本
============================================================
/*
定义一个医生类：
回想一下我们之前定义变量的时候，提过一个规范：见名之意。
我们根据见名之意的规范来重新定义形参的名字，运行后发现结果不对，值没有赋上。
*/
class Doctor {
private String name;
private int age;
private String gender;
public void setName(String name) {
//我们还说过，局部变量的使用原则：就近原则
//我们这里的name采用就近原则后发现，使用的都是形参的变量名name，没有使用成员变量中name.
//我们理想上应该是将传进来的name赋值给调用该方法对象中的成员变量name
//Doctor.name = name;直接通过类名.成员变量的方式目前是不行，我们还没有说过类似的用法，所以这个是有问题的
//如果这个Doctor对象存在的话，它是不是就表示了一个医生对象
//如果有一个东西可以代表是当前调用该方法的对象就好了
//java提供了一个关键字：this
//this在方法中使用的时候，就代表着调用该方法的对象
//既然都是一个对象了，我们学过对象.成员变量
// Doctor.name = name;
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int i) {
age = i;
}
public int getAge() {
return age;
}
public void setGender(String s) {
gender = s;
}
public String getGender() {
return gender;
}
//提供一个公共的方法
public void show() {
System.out.println("姓名：" + name + ",年龄：" + age + ",性别：" + gender);
}
}
public class DoctorDemo {
public static void main(String[] args) {
//创建一个医生对象
Doctor d = new Doctor();
d.setName("王宇");
d.setAge(18);
d.setGender("男");
d.show();
}
}
============================================================
317
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
