Java面向对象与类(一):类与对象,封装和构造方法
程序员文章站
2024-03-16 10:27:52
...
1.面向对象
- 面向过程: 需要实现一个功能的时候,每一个具体的步骤都要分步完成,详细处理每个细节
- 面向对象:需要实现一个功能,不关心具体步骤,找一个具有这个功能的函数,由它来完成实现.
import java.util.Arrays;
...
public static void main(String[] args) {
int[] array = {10,20,30,40,50};
//打印格式:{10,20,30,40,50}
//面向过程编程
System.out.print("{");
for(int i=0;i<array.length;i++){
if(i == array.length - 1){
System.out.println(array[i] + "]");
}
else {
System.out.print(array[i] + ",");
}
}
System.out.println("===========================");
//使用面向对象
//使用jdk提供的Arrays类,toString方法直接将数组变成格式化字符串
System.out.println(Arrays.toString(array));
}
- 特点
- 面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。
- 面向对象的语言中，包含了三大基本特征，即封装、继承和多态。
- 封装性
- 方法就是封装
- 关键字private(私有方法)就是一种封装
public static void main(String[] args) {
int[] array = {5,15,25,20,100};
int max = getMax(array);
System.out.println("最大值:"+max);
}
public static int getMax(int[] array){
int max = array[0];
for(int i=1;i<array.length;i++){
if(array[i]>max){
max = array[i];
}
}
return max;
}
- private关键字作用及使用
- 定义person的年龄时,无法阻止不合理的数值被设置进去
- 使用private关键字将需要保护的成员变量进行修饰
- 使用private进行修饰,在本类可以进行访问,类外部不能访问
- 间接访问private成员变量,定义一对getter/setter方法
...
public class Person {
String name;
private int age;
public void show(){
System.out.println("我叫"+name+",年龄:"+age);
}
//成员方法,专用于对age设置数据
public void setAge(int num){
age = num;
}
//成员方法,专用于获取age数据
public int getAge(){
return age;
}
...
public class Demo03Person {
public static void main(String[] args) {
Person person = new Person();
person.name = "赵丽颖";
person.setAge(20);
person.show();
}
- 对getter来说,不能有参数,返回值类型与成员变量对应
- 对setter来说,不能有返回值,参数类型与成员变量对应
- this关键字
- 方法局部变量和类的成员变量重名时,依据就近原则,优先使用局部变量
- 需要访问本类的成员变量,需要使用格式: this.成员变量名
- 通过谁调用的方法,谁就是this
System.out.println(name+",你好.我是"+this.name);
System.out.println(this);
2.类与对象
- 类: 是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该 类事物。
- 属性：就是该事物的状态信息。
- 行为：就是该事物能够做什么。
- 对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性 和行为
- 类与对象关系
- 类是对一类事物的描述，是抽象的。
- 对象是一类事物的实例，是具体的。
- 类是对象的模板，对象是类的实体。
- 类定义格式
- Java中用class描述事物也是如此
- 成员变量：对应事物的属性
- 成员方法：对应事物的行为
public class ClassName {
//成员变量
//成员方法
}
- 定义类：就是定义类的成员，包括成员变量和成员方法。
- 成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
- 成员方法：和以前定义方法几乎是一样的。只不过把static去掉
public class Student {
//成员变量
String name;
int age;
//成员方法1
public void study(){
System.out.println("好好学习,天天向上");
}
//成员方法2
public void eat(){
System.out.println("劳逸结合");
}
}
- 类的使用–根据类创建一个对象
- 导包,就是指出需要使用的类,在的位置 ; 对于和当前类属于同一个包的情况,可以省略导包语句不写
import 包名称.类名称;
- 创建,格式
类名称 对象名 = new 类名称();
Student stu = new Student();
- 使用类
- 使用成员变量 : 对象名.成员变量名
-
使用成员方法 : 对象名.成员方法名(参数)
成员变量默认值
| 数据类型 | 默认值 | |
|---|---|---|
| 基本类型 | 整数(byte,short,int,long) | 0 |
| 浮点数(float,double) | 0.0 | |
| 字符(char) | ‘\u0000’ | |
| 布尔(Boolean) | false | |
| 引用类型 | 数组,类,接口 | null |
- 改变对象中的成员变量数值内容,进行赋值操作,将右侧数据交给对象的成员变量
//手机类练习
...同一个包目录下
public class Phone {
//成员变量
//品牌,价格,颜色
String brand;
double price;
String color;
//成员方法
//打电话
public void call(String who){
System.out.println("给"+who+"打电话");
}
//群发短信
public void sendMessage(){
System.out.println("群发短信");
}
public class Demo01PhoneOne {
public static void main(String[] args) {
//根据phone类,创建一个one对象
//格式:类名称 对象名 = new 类名称();
Phone one = new Phone();
System.out.println(one.brand);//null
System.out.println(one.price);//0.0
System.out.println(one.color);//null
System.out.println("========================");
one.brand = "苹果";
one.price = 8388.0;
one.color = "蓝色";
System.out.println(one.brand);//苹果
System.out.println(one.price);//价格
System.out.println(one.color);//颜色
System.out.println("========================");
one.call("乔布斯");
one.sendMessage();
}
3.对象内存图
-
一个对象内存图
-
两个对象使用同一个方法内存图
-
两个引用指向同一个方法内存图
4.方法
- 使用对象类型作为方法参数
public static void main(String[] args) {
Phone one = new Phone();
one.brand = "苹果";
one.price = 8388.0;
one.color = "土豪金";
method(one);//传递地址值到参数中
}
public static void method(Phone param){
System.out.println(param.brand);
System.out.println(param.price);
System.out.println(param.color);
}
- 内存图
- 使用对象类型作为方法返回值
public static void main(String[] args) {
Phone two = getPhone();
System.out.println(two.brand);
System.out.println(two.price);
System.out.println(two.color);
}
public static Phone getPhone(){
Phone one = new Phone();
one.brand = "苹果";
one.price = 8388.0;
one.color = "玫瑰金";
return one;
}
- 内存图
5.成员变量和局部变量区别
- 定义位置不同
- 局部变量 : 方法内部
- 成员变量 : 方法外部,直接写在类中
- 作用范围不同
- 局部变量 : 仅仅在方法当中可以使用,除了方法就不能再用
- 成员变量 : 整个类全都通用
- 默认值不同
- 局部变量:无默认值,必须手动赋值
- 成员变量 : 无赋值,会有默认值,规则与数组一样
- 内存位置不同
- 局部变量: 位于栈内存
- 成员变量 : 位于堆内存
- 生命周期
- 局部变量 : 随着方法进栈二产生,随着方法出栈二消失
- 成员变量 ; 随着对象创建二产生,随着对象呗垃圾回收二消失
6.构造方法
- 构造方法:用来创建对象的方法,通过关键字new创建对象时,就是调用构造方法
- 格式:
public 类名称(参数类型 参数名称){
方法体;
}
- 注意事项
- 构造方法名称与所在的类名称完全一样
- 构造方法无返回值类型,void不能写
- 构造方法不能return一个返回值
- 如果没有任何构造方法,编译器就会默认赠送一个构造方法,没有方法体和参数(666!!!)
- 一旦编写了了至少一个构造方法,编译器不再赠送构造方法.(???)
- 构造方法也可以进行重载
public class Student {
//成员变量
private String name;
private int age;
//无参数构造方法
public Student(){
System.out.println("无参构造方法执行啦!!!");
}
//全参数构造方法
public Student(String name,int age){
System.out.println("全参构造方法执行啦!!!");
this.name = name;
this.age = age;
}
//getter和setter方法
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
}
//调用
public static void main(String[] args) {
//无参构造
Student stu1 = new Student();
System.out.println("========================");
//全参构造
Student stu2 = new Student("赵丽颖",18);
System.out.println("姓名:"+stu2.getName()+",年龄:"+stu2.getAge());
stu2.setAge(22);
System.out.println("姓名:"+stu2.getName()+",年龄:"+stu2.getAge());
}
7.标准类
- 标准类组成
- 所有成员变量所有private关键字修饰
- 为每一个成员变量编写一对getter和setter方法
- 编写一个无参数的构造方法
- 编写一个全参数的构造方法
public class student {
private String name;
private int age;
public student() {
}
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 setAge(int age) {
this.age = age;
}
推荐阅读