Java基础 --- 面向对象
面向对象
面向对象介绍
介绍
- 面向：拿、找
- 对象：能干活的东西
- 面向对象编程：拿东西过来坐对应的事情
设计对象并使用
类和对象
- 类（设计图）：是对象共同特征的描述；
- 对象：是真实存在的具体东西
在Java中，必须先设计类，才能获得对象。
如何定义类
public class 类名{
1.成员变量（代表属性，一般是名词）
2.成员方法（代表行为，一般是动词）
3.构造器（后面学习）
4.代码块（后面学习）
5.内部类（后面学习）
}
public class Phone {
String brand;
double print;
//行为（方法）
public void call(){
}
public void playGame(){
}
}
如何得到类的对象
类名 对象名 = new 类名();
Phone p = new Phone();
如何使用对象
- 访问属性：对象名.成员变量
- 访问行为：对象名.方法名(...)
范例：
public class Phone {
//属性
String brand;//手机的品牌
double price;//手机的价格
//行为
public void call(){
System.out.println("手机在打电话");
}
public void playGame(){
System.out.println("手机在玩游戏");
}
}
public class PhoneTest {
public static void main(String[] args) {
//创建手机的对象
Phone p = new Phone();
//给手机赋值
p.brand = "菠萝";
p.price = 1145.14;
//获取手机对象中的值
System.out.println(p.brand);
System.out.println(p.price);
//调用手机中的方法
p.call();
p.playGame();
//第二部手机
Phone p2 = new Phone();
p2.brand = "鸭梨";
p2.price = 1008.6;
p2.call();
p2.playGame();
}
}
总结
-
类和对象是什么？
- 类：是对象共同特征的描述（设计图）；对象：是真实存在的具体实例。
-
如何得到对象？
public class 类名{ 1.成员变量（代表属性，一般是名词） 2.成员方法（代表行为，一般是动词） }类名 对象名 = new 类名(); -
拿到对象后能做什么？
- 对象名.成员变量
- 对象名.方法名(...)
类的几个补充注意事项
-
用来描述一类事物的类，专业叫做： Javabean类。
在Javabean类中，是不写main方法的。
-
在以前，编写main方法的类，叫做测试类。
我们可以在测试类中创建javabean类的对象并进行赋值调用。
public class 类名{
1.成员变量（代表属性）
2.成员方法（代表行为）
}
-
类名首字母建议大写，需要见名知意，驼峰模式。
-
一个Java文件中可以定义多个class类，且只能一 个类是public修饰，而且public修饰的类名必须成为代码文件名。
实际开发中建议还是一个文件定义一个class类。
-
成员变量的完整定义格式是: 修饰符 数据类型 变量名称 = 初始化值；一般无需指定初始化值，存在默认值。
数据类型 明细 默认值 基本类型 byte、short、int、long 0 基本类型 float、double 0.0 基本类型 boolean false 引用类型 类、接口、数组、String null
练习
女朋友类
编写女朋友类，创建女朋友类的对象
给女朋友的属性赋值并调用女朋友类中的方法。
自己思考，女朋友类中有哪些属性，有哪些行为？
public class GirlFriendTest {
public static void main(String[] args) {
//创建女朋友的对象
GirlFriend gf1 = new GirlFriend();
gf1.name = "柳如烟";
gf1.age = 18;
gf1.gender = "女神";
System.out.println(gf1.name);
System.out.println(gf1.age);
System.out.println(gf1.gender);
gf1.sleep();
gf1.eat();
System.out.println("=====================================");
GirlFriend gf2 = new GirlFriend();
gf2.name = "苏沐雪";
gf2.age = 19;
gf2.gender = "青梅竹马";
System.out.println(gf2.name);
System.out.println(gf2.age);
System.out.println(gf2.gender);
gf2.sleep();
gf2.eat();
}
}
总结
-
定义类有哪些建议，有什么需要注意的?
-
类名首字母建议大写、英文、有意义，满足驼峰模式，不能用关键字，满足标志符规定；
-
一个代码文件中可以定义多个类，但是只能一个类是public修饰的，
public修饰的类名必须是Java代码的文件名称。
-
-
成员变量的格式是什么样的，有什么特点?
- 成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值;
- 一般无需指定初始化值。
封装
告诉我们，如何正确设计对象的属性和方法
原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为
封装的好处
- 让编程变得很简单，有什么事，找对象，调方法就行。
- 降低我们的学习成本，可以少学、少记，或者说压根不用学，不用记对象有哪些方法，有需要时去找就行
private关键字
- 是一个权限修饰符
- 可以修饰成员（成员变量和成员方法）
- private修饰的成员只能在本类中才能访问
public class GirlFriend {
private String name;
private int age;
private String gender;
//针对于每个私有化的成员变量，都要提供get和set方法
//set方法：给成员变量赋值
//get方法；对外提供成员变量的值
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
public void setAge(int a){
if(a >= 0 && a <= 100){
age = a;
}else {
System.out.println("非法参数");
}
}
public int getAge(){
return age;
}
public void setGender(String g){
gender = g;
}
public String getGender(){
return gender;
}
//行为
public void sleep(){
System.out.println("女朋友在睡觉");
}
public void eat(){
System.out.println("女朋友在吃饭");
}
}
public class GirlFriendTest {
public static void main(String[] args) {
GirlFriend gf1 = new GirlFriend();
gf1.setName("柳如烟");
gf1.setAge(18);
gf1.setGender("女");
System.out.println(gf1.getName());
System.out.println(gf1.getAge());
System.out.println(gf1.getGender());
gf1.sleep();
gf1.eat();
}
}
总结
- private关键字是一个权限修饰符
- 可以修饰成员（成员变量和成员方法）
- 被private修饰的成员只能在本类中才能访问
- 针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
- 提供“setxxx(参数)”方法，用于给成员变量赋值，方法用public修饰
- 提供"getxxx()"方法，用于获取成员变量的值，方法用public修饰
就近原则和this关键字
就近原则
- 谁离我近我就用谁
成员变量和局部变量
public class GirlFriend{
private int age;//成员变量
public void method(){
int age = 10;//局部变量
System.out.println(age);//打印局部变量
}
}
public class GirlFriend{
private int age;//成员变量
public void method(){
int age = 10;//局部变量
System.out.println(this.age);//打印成员变量
}
}
范例：
public class GirlFriend {
private String name;
private int age;
private String gender;
//针对于每个私有化的成员变量，都要提供get和set方法
//set方法：给成员变量赋值
//get方法；对外提供成员变量的值
//作用：给成员变量name进行赋值的·
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
if(age >= 0 && age <= 100){
this.age = age;
}else {
System.out.println("非法参数");
}
}
public int getAge(){
return age;
}
public void setGender(String gender){
this.gender = gender;
}
public String getGender(){
return gender;
}
//行为
public void sleep(){
System.out.println("女朋友在睡觉");
}
public void eat(){
System.out.println("女朋友在吃饭");
}
}
public class GirlFriendTest {
public static void main(String[] args) {
GirlFriend gf1 = new GirlFriend();
gf1.setName("柳如烟");
gf1.setAge(18);
gf1.setGender("女");
System.out.println(gf1.getName());
System.out.println(gf1.getAge());
System.out.println(gf1.getGender());
gf1.sleep();
gf1.eat();
}
}
总结
- 就近原则
- this作用：区别成员变量和局部变量
- this的本质和内存图
构造方法
概述：
- 构造方法也叫做构造器、构造函数。
- 作用：在创建对象的时候给成员变量进行赋值的。
格式：
public class Student{
修饰符 类名(参数){
方法体;
}
}
特点：
- 方法名和类名相同，大小写也要一致
- 没有返回值类型，练void都没有
- 没有具体的返回值（不能有return带回结果数据）
执行时机：
- 创建对象的时候有虚拟机调用，不能手动调用构造方法
- 每创建一次对象，就会调用一次构造方法
public class Student {
private String name;
private int age;
//如果我们自己没有写任何的构造方法
//那么虚拟机就会给我们加一个空参构造方法
public Student (){
System.out.println("故乡的樱花开了");
}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void set(int age){
this.age = age;
}
}
public class StudentTest {
public static void main(String[] args) {
//创建对象
//调用的空参构造
//Student s = new Student();
Student s = new Student("柳如烟",18);
System.out.println(s.getName());
System.out.println(s.getAge());
}
}
构造方法注意事项
- 构造方法的定义
- 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
- 如果定义了构造方法，系统将不再提供默认的构造方法
- 构造方法的重载
- 带参构造方法，和无参构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载
- 推荐的使用方法
- 无论是否使用，都手动书写无参构造方法，和带全部参数的构造方法
总结
- 构造方法的作用？
- 创造对象的时候，有虚拟机自动调用，给成员变量进行初始化的。
- 构造方法有几种，各自的作用是什么？
- 无参数构造方法：初始化的对象时，成员变量的数据均采用默认值。
- 有参数构造方法：在初始化对象的时候，同时可以为对象进行赋值。
- 构造方法有哪些注意事项？
- 任何类定义出来，默认就自带了无参数构造器，写不写都有。
- 一旦定义有参数构造器，无参数构造器就没有了，此时就需要自己写有参数构造器了。
- 建议在任何时候都手动写上空参和带全部参数的构造方法。
- 创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。
标准JavaBean
标准JavaBean类
- 类名需要见名知意
- 成员变量使用private修饰
- 提供至少两个构造方法
- 无参构造方法
- 带全部参数的构造方法
- 成员方法
- 提供每一个成员变量对应的setXxx()/getXxx()
- 如果还有其他行为，也要写上
范例：
public class User {
//属性
private String username;
private String password;
private String email;
private String gender;
private int age;
//快捷键：
//alt + insert
//alt + Fn + insert
//插件PTG 1秒生成标准JavaBean（右键空白处，点击倒数第三个）
//空参
public User(){}
//带全部参数的构造
public User(String username,String password,String email,String gender,int age){
this.username = username;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
//get和set方法
public String getUsername(){
return username;
}
public void setUsername(String username){
this.username = username;
}
public String getPassword(){
return password;
}
public void setPassword(String password){
this.password = password;
}
public String getEmail(){
return email;
}
public void setEmail(String email){
this.email = email;
}
public String getGender(){
return gender;
}
public void setGender(String gender){
this.gender = gender;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
}
对象内存图
一个对象的内存图
Student s = new Student();
- 加载class文件
- 申明局部变量
- 在堆内存中开辟一个空间
- 默认初始化
- 显示初始化
- 构造方法初始化
- 将堆内存中的地址值赋值给左边的变量
两个对象的内存图
两个引用指向同意一个对象
基本数据类型和引用数据类型
基本数据类型
- 在变量当中存储的是真实的数据值
引用数据类型
- 使用其他空间的数据
从内存的角度去解释：
- 基本数据类型：数据值是存储在自己的空间中
- 特点：复制给其他变量，也是赋的真实的值。
- 引用数据类型：数据值是存储在其他空间中，自己空间中存储的是地址值。
- 特点：赋值给其他变量，赋的是地址值。
this的内存原理
- this的作用：区分局部变量和成员变量
- this的本质：所在方法调用者的地址值
成员变量和局部变量的区别
成员变量：类中方法外的变量
局部变量：方法中的变量
| 区别 | 成员变量 | 局部变量 |
|---|---|---|
| 类中位置不同 | 类中，方法外 | 方法内、方法申明上 |
| 初始化值不同 | 有默认初始化值 | 没有， 使用之前需要完成赋值 |
| 内存位置不同 | 堆内存 | 栈内存 |
| 生命周期不同 | 随着对象的创建而存在，随着对象的消失而消失 | 随着方法的调用而存在， 随着方法的运行结束而消失 |
| 作用域 | 整个类中有效 | 当前方法中有效 |