这篇博客主要介绍了Java的面向对象思想，包括封装的概念、封装的好处和应用，以及类和对象的关系、成员变量与局部变量的区别。此外，还详细讲解了方法参数、构造方法的重载和创建对象的过程，最后提到了代码块的种类及其执行顺序。
面向过程思想概述
在程序设计思想当中有两种主流思想：
- 面向过程：当需要实现一个功能时，每一个过程都亲力亲为，详细处理每一个细节，例如C语言就是面向过程是语言
- 面向对象：就是偷懒，当需要实现一个功能时，不自己做，而是找一个已具有该功能的人，帮自己做。
面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求
面向过程的代表语言：C语言
面向对象之封装
封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装的案例引入
封装之前先看一个案例
// 定义一个学生类
public class Student {
int age;
String name;
public void study(){
System.out.println("我爱敲代码");
}
}
// 测试类
public class Test01 {
public static void main(String[] args) {
Student s = new Student();
s.age=-10;
System.out.println(s.age);
}
}
- 这时候你发现这么写是不符合规范的，因为年龄是不可能为负的； 这说明是个对象就可以访问属性，随便赋值，这样不行，我得想个办法不让其让问；
提供一个特有的方法访问赋值；这个就是封装；
封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装的好处：
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
封装的设计原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
面向对象开发、设计、特征
- 面向对象开发：就是不断的创建对象，使用对象，指挥对象做事情
- 面向对象设计：其实就是在管理和维护对象之间的关系。
- 面向对象特征：封装，继承，多态
类和对象的关系
- 类：是一组相关的属性和行为的集合
- 对象：是该类事物的具体体现（是类的具体化实例）
关系：对象是类的派生，类是对象的总结
类：可以理解为构造对象的一个蓝图或者模版，是抽象的概念
对象：是以类为模型创建的具体实例，是对类的一种具体化。
成员变量和局部变量的区别
在类中的位置不同 ：
成员变量 类中方法外
局部变量 方法内或者方法声明上
在内存中的位置不同：
成员变量 堆内存
局部变量 栈内存
生命周期不同 ：
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
初始化值（默认值）不同：
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
方法形式参数为类名时如何调用
- 基本数据类型参数传递
//求两个整数和案例
public class Sum {
// 定义求和的方法、这里的a、b就是形式参数，没有具体的值，等待被赋值；
public int sum(int a,int b){
return a+b;
}
}
// 测试类
public class Test01 {
public static void main(String[] args) {
// 创建对象
Sum s1 = new Sum();
int a=3;
int b=4;
// 传递参数调用方法
int c = s1.sum(a, b);//这里的a、b就是实际参数；有具体的值；给形式参数赋值；
System.out.println(c);
}
}
- 引用数据类型参数传递
//其实很简单，就是把参数 int a 换成 Student s即可；
注意：引用类型类类型当做参数时，传递的是其对象
案例：
public class ChuShi {
// 做菜的方法
public void zuoCai(){
System.out.println("宫保鸡丁做好了....");
}
}
public class FuWuYuan {
// 服务员可以指挥厨师做菜（因为他可以接受客户的点菜请求）
// //这个方法里面的形式参数是一个类类型，属于引用数据类型，传递实参时，应该是该类的一个对象
public void dianCai(ChuShi cs){//调用的时候，是把main中创建的Chushi的对象cs的地址传递过来
cs.zuoCai();
}}
public class KeRen {
public static void main(String[] args) {
// 点菜 （创建对象）
FuWuYuan fwy = new FuWuYuan();
// 点菜--调用方法
ChuShi cs = new ChuShi();
// 调用方法执行做菜
fwy.dianCai(cs);
}}
标准的类的封装案例及测试
封装案例的实现
public class Student {
//学生有姓名，年龄，性别属性，将这些属性私有化(封装)
private String name;
private int age;
private String sex;
//提供公共的setXxx(),getXxx()方法
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;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
//学习方法
public void study(){
System.out.println("Good Good Study,Day Day Up");
}
}
封装案例中的成员的书写规范：
成员变量用private私有化
提供公共的set/get方法
构造方法的概述和格式
构造方法的作用
public class Student {
private int age;
private String name;
// 构造方法
public Student(){
System.out.println("每当创建对象时都会访问次方法");
}
}
// 测试类
public class Test01 {
public static void main(String[] args) {
Student s = new Student();
}}
构造方法的格式：
- 方法名与类名相同
- 没有返回值类型，连void都没有
- 没有具体的返回值
- 格式：修饰符 类名(){……},常见的修饰符为public
构造方法的重载及注意事项
方法的重载特点：方法名相同，参数列表不同
构造方法也是个方法，它也可以实现方法的重载
如果我们没有给出构造方法，系统将自动提供一个无参构造 如果我们给出了构造方法，系统将不再提供默认的无参构造
演示构造方法的重载，再将无参构造注释，演示，得出下面这句话
注意：这个时候，如果我还想用无参构造，就必须自己定义，建议永远自己给出无参构造方法
案例：我们自己提供一个构造方法，不要系统默认的；
public class Student {
int age; //这里没有使用private
String name;
public Student(int age , String name){
this.name=name;
this.age=age;
}}
// 测试类：
public class Test01 {
public static void main(String[] args) {
//调用构造方法
Student s = new Student(27,"roy");
System.out.println("年龄："+s.age+"姓名："+s.name);
}
}
构造方法升级版 添加set和get方法的 因为刚才我们没有使用private
public class Student {
private int age;
private String name;
//构造方法：这个带参数的被称为有参构造方法；
// 刚才那个没有参数的构造方法，被称为无参构造方法；
public Student(int age , String name){
this.name=name;
this.age=age;
}
// set和get方法
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// 测试类
public class Test01 {
public static void main(String[] args) {
// 构造方法就是给对象初始化赋值的；
Student s = new Student(27,"roy");
System.out.println(s.getAge()+":"+s.getName());
}
}
再来升级版： 构造方法重载
public class Student {
private int age;
private String name;
// 无参构造
public Student(){
}
//有参构造
public Student(int age , String name){
this.name=name;
this.age=age;
}
// 有参构造重载
public Student(int age){
this.age=age;
}
public Student(String name){
this.name=name;
}
// set和get方法
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// 测试类
public class Test01 {
public static void main(String[] args) {
Student s = new Student(27,"roy");
System.out.println(s.getAge()+":"+s.getName());
// 使用单个参数的构造方法给年龄赋值
Student s2 = new Student(22);
System.out.println("s2的年龄："+s2.getAge()+" ;s2的姓名："+s2.getName());
// 使用单个参数的构造方法给姓名赋值
Student s3 = new Student("郭碧婷");
System.out.println("s3的年龄："+s3.getAge()+" ;s3的姓名："+s3.getName());
}
}
总结：
-
如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
-
如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
创建对象做了那些事情
初始化过程：
- Student s = new Student();
- 加载Student.class文件进内存
- 在栈内存为s开辟空间
- 在堆内存为学生对象开辟空间
- 堆学生对象的成员变量进行默认初始化
- 对学生对象的成员变量进行显示初始化
- 通过构造方法对学生对象的成员变量赋值
- 学生对象初始化完毕，把对象地址赋值给s变量
图解：
代码块的概述和分类
- 在Java中，使用{}括起来的代码被称为代码块
- 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
静态代码块
- 静态代码块的格式
静态代码块 在类中方法外出现，加了static修饰 - 静态代码块的特点
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。（当第一次用到本类时静态代码块执行唯一的一次） - 静态代码块的作用
一般是对类进行初始化（它仅能初始化类变量，即static修饰的成员变量）
构造代码块
- 构造代码块的作用
可以把多个构造方法中的共同代码放到一起，对对象进行初始化 - 构造代码块的执行顺序
每次调用构造都执行，并且在构造方法前执行
局部代码块
- 局部代码块的定义格式
在方法中出现；
{
} - 局部代码块的作用
限定变量生命周期，及早释放，提高内存利用率 - 局部代码块的调用时间
所在的方法被调用，它也被执行
静态代码块,构造代码块,构造方法的执行顺序?
静态代码块 – 构造代码块 – 构造方法
静态代码块：只执行一次
构造代码块：每次调用构造方法都执行
案例：
public class DaiMaKuai {
public static void main(String[] args) {
// TODO Auto-generated method stub
//局部代码块：方法中
//格式：
//System.out.println(x);
//创建对象
Code code = new Code();
Code code2 = new Code();
{
int x = 10;
System.out.println(x);
}
}
}
public class Code {
//构造代码块：位置：类中方法外
//格式：
{
System.out.println("这是构造代码块");
}
//静态代码块：位置：类中方法外
//格式：
static{
System.out.println("这是静态代码块");
}
//定义一个构造方法
public Code(){
System.out.println("构造方法");
}
//面试题：三者的执行顺序：静态代码块，然后构造代码块，最后构造方法
//静态代码块只能被执行一次
}
构造代码块，静态代码块的区别：
静态代码块作用于类，主要用于类的初始化操作，并且只执行一次;
构造代码块作用于对象，主要用于对象的初始化操作，只要有对象创建都会执行，并且优先级由于构造函数；
扫一扫
1万+
到【灌水乐园】发言
