南哥带你玩转 Java 之 Java 类和对象

Java 类和对象

类:对一类事物行为和状态的抽象描述(图纸、模板)
对象:用类实例出来的具体事物(房子)

定义一个类，使用 class 修饰
注意：一个文件中，只运行一个 public 修饰的类

类中包含:
对类的描述:(属性和行为)
属性:一般都使用名词来修饰
行为:一般都使用动词来修饰

类中写
成员变量(实例方法)写在类中方法外
成员方法(实力方法)写在类中

创建对象:
类名 对象名 = 初值;
类名 对象名 = new 类名();

例如:
// 创建一个对象
Animal dog = new Animal();
// 访问成员变量:对象.成员变量
// 如果成员变量在等号前面叫赋值,等号后面叫获取
// 给成员变量赋值
dog.name = "来福";
// 获取成员变量
String stringName = dog.name;
System.out.println(stringName);
// 调用成员方法:对象.方法
dog.sayHi();
dog.eat();
dog.sleep();
// 创建一个动物类 (姓名,年龄,雌雄,会介绍自己,睡觉,觅食)
// 思考:如果在类中声明成员变量没有给初值,那么这个变量有初值吗?
// 有,因为对象创建在堆内存(堆内存中有默认的初始值)

class Animal {
// 成员变量的作用域是整个类中都可以访问到
String name = "旺财"; // 姓名
int age = 2;                // 年龄
String gender = "公";    // 性别

// 成员方法
public void sayHi() {
System.out.println("名字:" + name);
System.out.println("年龄:" + age);
System.out.println("性别:" + gender);
}
// 睡觉
public void sleep() {
System.out.println(name + "zzz~");
}
// 觅食
public void eat() {
System.out.println(name + "进食");
}

}

匿名对象
1.如果只调用方法,这时可以使用匿名对象(测试时会调用)
2.匿名对象可以当做参数进行传递

好处:当参数时,代码简便
弊端:无法直接修改里面的值

new Person().introduce();
new Person().username ="007";
new Person().introduce();

思考:
// 方法需要什么参数,就创建什么参数传进去
// 当参数为引用数据类型时,需要创建出这个对象,然后将地址穿进去
// 你需要创建出这个对象,然后将地址穿进去
// 有几个对象 几个引用? 这块内存空间,有多少人使用它
Person p = new Person();
Person person10 = create("王10", p);
person10.introduce();
p.introduce();
Person p2 = person10;
p2.introduce();
p2.username = "王 p2";
p2.introduce();

// 创建一个人
Person person = new Person();
person.username = "刘一";
person.password = "1";
person.randomNum = (int)(Math.random() * (9999 - 1000 + 1) + 1000);
person.introduce();
// 创建一群人
create("陈二", "2", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
create("张三", "3", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
create("李四", "4", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
create("王五", "5", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
create("赵六", "6", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
create("孙七", "7", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
create("周八", "8", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
create("吴九", "9", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
create("郑十", "0", (int)(Math.random() * (9999 - 1000 + 1) + 1000));
// 创建对象
public static Person create(String username, String password, int randomNum) {
Person person = new Person();
person.username = username;
person.password = password;
person.randomNum = randomNum;
person.introduce();
return person;
}public static Person create(String username, Person p) {
Person person = new Person();
person.username = username;
person.introduce();
return person;
}

class Person{
String username;
String password;
int randomNum;

// 介绍自己
public void introduce() {
System.out.println("用户名:" + username);
System.out.println("密码:" + password);
System.out.println("卡号:" + randomNum);
}
}

思考:类能不能重名?
可以,在不同 Package 下可以重名使用

例如:
com.lanou3g.bean.Cat cat = new com.lanou3g.bean.Cat();
cat.setName("大花");
cat.setColor("黄色");
cat.setBreed("波斯猫");
cat.sayHi();
cat.eatFish();
cat.actingCute();
cat.getCaught();

// 创建 bean1包下得到 Cat 对象
// 如果类名相同的话,创建对象的时候
// 要
e18f
使用全限定类名(包名 + 类名)
// com.lanou3g.bean1.Cat cat1 = new com.lanou3g.bean1.Cat();
// cat1.sayHi();

public class Cat {
private String name;
private String color;
private String breed;

// 无参构造方法
public Cat() {
name = "阿花";
color = "七彩";
breed = "biubiu 喵";
System.out.println("构造方法");
}

// 有参构造方法
public Cat(String name, String color, String breed) {
this.name = name;
this.color = color;
this.breed = breed;
System.out.println("构造方法");
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getBreed() {
return breed;
}
public void setBreed(String breed) {
this.breed = breed;
}

public void eatFish() {
System.out.println("吃鱼");
}

public void actingCute() {
System.out.println("卖萌,喵~");
}

public void getCaught() {
System.out.println("被老鼠抓,难受");
}

public void sayHi() {
System.out.println(getName());
System.out.println(getBreed());
System.out.println(getColor());
}

}

构造方法

构造方法:初始化成员变量的
注意:
1.构造方法 没有返回值甚至不写返回值的类型
2.构造方法的方法名与类名相同
写法:
关键字 构造方法名(){

}

构造方法注意事项：
1. 如果你没写无参的构造方法
系统会给你提供一个无参的构造方法
2. 如果我只写了 有参的构造方法
这时 系统就不再给你提供无参的构造方法
3. 写类的时候 建议 无参 有参 构造方法 全写
定义类 书写顺序
成员变量 -> 无参 有参 构造方法 -> set/get方法 ->成员方法

get/set 方法

成员变量私有化时,需要使用 get/set 方法来获取/修改成员变量

例如:
Student student = new Student();
// 使用 get/set 方法
student.setName("student_1");
student.setAge(21);
student.sayHi();

class  Student {
// 成员变量私有化(只能本类进行访问,本类以为无法访问)
// 不能通过对象.属性来直接访问
// 但是可以通过方法来间接访问
private String name;
private int age;

// get/set 方法
// 命名规范:以 get/set 开头,使用小驼峰写法
// 获取
public String getName() {
return name;
}
// 修改
public void setName(String name) {
// 提供关键字 this 代表本类的对象
// 哪个对象调用这个方法,这个对象就是 this
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

// 就近原则(这里会打印局部变量
public void sayHi() {
String name = "爱上了登记卡死";
System.out.println(name);
System.out.println(getName());
System.out.println(getAge());
}

}

成员变量和局部变量的区别

1.书写位置
成员变量:类中方法外
局部变量:方法中或方法声明上
2.内存中的位置
成员变量:存在于堆内存中
局部变量:加载到栈内存中
3.初值
成员变量:有默认初始值(堆给的)
局部变量:无默认值,如果要调用,必须要赋予初值
4.生命周期
成员变量:随着对象的创建/销毁而创建/销毁
局部变量:随着方法存在

例如:
// 创建对象
Car car = new Car();
// 赋值
car.brand = "玛莎拉蒂";
car.color = "红色";
car.tire = "4";
// 调用对象中的方法
car.introduce();
car.move();
car.thrustInto();

class Car {
String brand;   // 牌子
String color;   // 颜色
String tire;        // 轮胎个数(数据类型只要符合逻辑,即可定义,例如 tire 不能用 double 来定义)

// 会动
public void move() {
// 局部变量
// 声明位置: 方法中或者方法声明上(参数位置)
int num = 0;
System.out.println(num);
System.out.println(brand + "飘逸");
}
// 会撞人
public void thrustInto() {
System.out.println(brand + "飘逸速度太快了,撞人了");
}
// 介绍自己
public void introduce() {
System.out.println("品牌:" + brand);
System.out.println("颜色:" + color);
System.out.println("轮胎:" + tire);
}
}

静态变量

静态变量 (使用static修饰)
静态变量保存在 方法区的 静态区(共享区)
静态变量是共享区间

静态变量 如何调用?
1. 可以使用 对象来调用
2. 可以使用 类名来调用(推荐)

为什么静态变量要使用 类名 去调用??
因为 只要加载了.class文件 就加载了静态变量(这时 还没有对象产生)

静态变量(属于类 也叫 类变量)
非静态变量(属于对象 也叫 对象变量)
这两者的区别是什么?

1.调用方式不同
静态变量:   对象或类名去调用(推荐 类名)
非静态变量: 只能使用 对象去调用
2.内存中存在的位置不同
静态变量:   方法区的静态区
非静态变量: 堆内存
3.加载的时机不同
静态变量:   随着类的加载而加载(不依赖对象而加载)
非静态变量: 随着对象的创建而创建(以来对象)
4.生命周期不同
静态变量:   随着类的销毁而销毁(相当于程序结束)
非静态变量: 随着对象的销毁而销毁

静态变量在内存中加载步骤
1. 加载.class文件(字节码文件) 到方法区
2. main方法入栈
3. 要创建AVGirl的对象 先要加载 AVGirl.class
AVGilr.class 中 分为 静态区和非静态区
这时 初始化静态变量county 初值为 null;
4. 创建对象(堆区开辟空间)
5. 把对象的地址 赋值给 girl1 变量 保存
6. 通过类名 修改 类变量的值
7. sayHi 方法 入栈 打印
8. sayHi 出栈
9. main 出栈

静态方法

静态方法(使用static修饰的方法)
非静态方法:
1.可以使用静态变量和非静态变量
2.可以使用静态方法和非静态方法

静态方法:
1.只能使用静态变量
2.只能使用静态方法

例如:
public static void main(String[] args) {
Man man = new Man();
man.fun();
}
}

class Man{
int num1 = 10;
static int num2 = 5;
// 非静态方法 可以访问 静态变量 和 非静态变量
// 静态方法 可以访问谁?(加上静态 相当于 随着类改变 跟对象没关系)
public void fun() {
System.out.println(this.num1);
System.out.println(Man.num2);

//调用静态方法(类方法) 推荐使用 类名 调方法
Man.fun1();
}

//静态方法
//静态方法中 不能访问 非静态变量(因为 加载类的时候 还没有对象)
//简单记: 静态只能使用静态的
public static void fun1(){
//System.out.println(num1);
System.out.println(num2);
}

main 解析

main就是为了让jvm去调用的方法

public jvm调用这个方法 要使用最大权限

static jvm调用时是不需要创建对象的 直接使用类名调就行

main 不是关键字  jvm 只认识 main这个词

String[] args  接收键盘输入的值

面向对象

面向过程
面向对象:
1.更贴近人的思想(懒人思想)
2.从事物的执行者转换为事物的指挥者

面向对象的特征
1.封装
2.继承
3.多态

封装:将类中属性或方法对外界隐藏,然后提供公共的访问方式
成员变量私有化是封装的一种体现

权限修饰符
作用： 用于控制被修饰变量、方法、类的可见范围.
public:     公开
protected:  受保护
default:    默认
private:    私有