java面向对象(一)：类和对象，封装，this关键字，static关键字，代码块_项目三类与对象及创建

读者福利

========

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

由于篇幅过长，就不展示所有面试题了，想要完整面试题目的朋友（另有小编自己整理的2024大厂高频面试题及答案附赠）

1.2、构造方法

类中有一种特殊的成员方法，其方法名与类名相同，称为构造方法(也称构造器)。构造方法的作用是：当new一个新对象时，系统将自动调用构造方法初始化该对象的数据。

格式：         A:方法名与类名相同         B:没有返回值类型，连void都没有         C:没有具体的返回值     构造方法的注意事项:         A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。         B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。             注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法              给成员变量赋值有两种方式：         A:setXxx()         B:构造方法

构造方法的案例：
class Student {     private String name;     private int age;     public Student() {         System.out.println(“这是无参构造方法”);         //这里的println打印，到对象调用到的带void方法时，会先打印这里内容再打印对象void方法的内容     }          //构造方法的重载格式     public Student(String name) {         System.out.println(“这是带一个String类型的构造方法”);         this.name = name;     }          public Student(int age) {         System.out.println(“这是带一个int类型的构造方法”);         this.age = age;     }          public Student(String name,int age) {         System.out.println(“这是一个带多个参数的构造方法”);         this.name = name;         this.age = age;     }          public void show() {         System.out.println(name+“—”+age);     } } class test {     public static void main(String[] args) {         //创建对象         Student s = new Student();  //调用无参构造方法         s.show();         System.out.println(“-------------”);                  //创建对象2         Student s2 = new Student(“林青霞”);         s2.show();            System.out.println(“-------------”);                  //创建对象3         Student s3 = new Student(27);         s3.show();         System.out.println(“-------------”);                  //创建对象4         Student s4 = new Student(“林青霞”,27);  //调用有参构造方法         s4.show();     } } //以下截取部分结果(无参构造方法的s.show()调用的结果)： 这是无参构造方法 null—0 -------------

1.3、形式参数是类名的问题

/*     形式参数的问题：         基本类型：形式参数的改变不影响实际参数         引用类型：形式参数的改变直接影响实际参数 */ //形式参数是基本类型 class Demo {     public int sum(int a,int b) {         return a + b;     } } //形式参数是引用类型 class Student {     public void show() {         System.out.println(“我爱学习”);     } } class StudentDemo {     //如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。     public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();         s.show();     } } class ArgsTest {     public static void main(String[] args) {         //形式参数是基本类型的调用         Demo d = new Demo();         int result = d.sum(10,20);         System.out.println(“result:”+result);         System.out.println(“--------------”);                  //形式参数是引用类型的调用         //需求：我要调用StudentDemo类中的method()方法         StudentDemo sd = new StudentDemo();         //创建学生对象         Student s = new Student();         sd.method(s); //把s的地址给到了这里     } }

1.4、匿名对象

/*     匿名对象：就是没有名字的对象。     匿名对象的应用场景：         A:调用方法，仅仅只调用一次的时候。             注意：调用多次的时候，不适合。             那么，这种匿名调用有什么好处吗?                 有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。         B:匿名对象可以作为实际参数传递 */ class Student {     public void show() {         System.out.println(“我爱学习”);     } } class StudentDemo {     public void method(Student s) {         s.show();     } } class NoNameDemo {     public static void main(String[] args) {         //带名字的调用         Student s = new Student();         s.show();         s.show();         System.out.println(“--------------”);                  //匿名对象         //new Student();         //匿名对象调用方法         new Student().show();         new Student().show(); //这里其实是重新创建了一个新的对象         System.out.println(“--------------”);                           //匿名对象作为实际参数传递         StudentDemo sd = new StudentDemo();         //Student ss = new Student();         //sd.method(ss); //这里的s是一个实际参数         //匿名对象         sd.method(new Student());                  //在来一个         new StudentDemo().method(new Student());      } }

1.5 创建对象时内存的过程和图解

Student s = new Student();在内存中做了哪些事情?

（1）加载Student.class文件进内存

（2）在栈内存为s开辟空间

（3）在堆内存为学生对象开辟空间

对学生对象的成员变量进行默认初始化  //null  0

对学生对象的成员变量进行显示初始化   //林青霞 27

通过构造方法对学生对象的成员变量赋值  //刘意  30

（4）学生对象初始化完毕，把对象地址赋值给s变量  //0x0001

2、类的封装

类的封装性原则：即要提供类与外部的联系，又要尽可能隐藏类的实现细节。

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。就是说我可以提供功能给你用，但是你不需要了解我怎样实现的，这在生产环境中至关重要，有牵扯到一些技术专利等问题，同时封装也提供一定程度的安全性。

封装的好处：
A:隐藏实现细节，提供公共的访问方式         B:提高代码的复用性         C:提高代码的安全性

类的封装性是通过为类及成员变量和成员方法分别设置合理的访问权限实现的。

2.1、访问权限

在java中共有4种访问权限，如下图：

权限修饰符	本类	本类所在包	其他包中子类	其他包中非子类
public	√	√	√	√
protected	√	√	√	×
默认	√	√	×	×
private	√	×	×	×

由上图可知，public是公共类，protected为是继承的子类权限设计的，默认是同一个包中的类有互相访问权限，private只限本类访问。

简单的java封装案例：
class Demo {     //int num = 10;     //用private修饰     private int num = 10;          public void show() {         System.out.println(num);     }          private void method() {         System.out.println(“method”);     }          public void function() {         method();     } } class PrivateDemo {     public static void main(String[] args) {         Demo d = new Demo();         //不能方法私有的成员变量         //System.out.println(d.num);         d.show();          //不能访问私有的成员方法         //d.method();         d.function();          //虽然在main方法中不能直接访问私有的成员变量、成员方法，但可以通过Demo类的public修饰的成员方法间接访问Demo类的private修饰的成员变量、成员方法      } }

由上代码可知，在同一个类中，通过public修饰的成员方法间接访问private修饰的成员变量、成员方法的过程就是封装的体现。由此也引出了任何一个实体类，带有了getXxx()和setXxx()的成员方法，通过setXxx()方法设置类中private的成员变量的值，而getXxx()方法可以得到private的成员变量的值。

java的getXxx()和setXxx()方法的封闭案例：
/*     封装和private的应用：         A:把成员变量用private修饰         B:提高对应的getXxx()和setXxx()方法 */ //定义学生类 class Student {     //姓名     private String name;     //年龄     private int age;          //姓名获取值     public String getName() {         return name;     }          //姓名设置值     public void setName(String n) {         name = n;     }          //年龄获取值     public int getAge() {         return age;     }          //年龄赋值     public void setAge(int a) {         age = a;     } } //测试类 class StudentTest {     public static void main(String[] args) {         //创建学生对象         Student s = new Student();                  //使用成员变量         //错误：被私有修饰了，外界不能直接访问了         //System.out.println(s.name+“—”+s.age);         System.out.println(s.getName()+“—”+s.getAge());                  //给成员变量赋值         //s.name = “林青霞”;         //s.age = 27;         //通过方法给赋值         s.setName(“林青霞”);         s.setAge(27);         System.out.println(s.getName()+“—”+s.getAge());     } }

从上代码看出，都是 getName() 或 setName() 成员方法返回或赋值给Student类的成员变量name，但如果在getName()或setName() 的成员方法中定义多一个局部变量num时，就会容易出问题了。因为方法的局部变量优先级>类的成员变量的，在同名的情况下，变量名相同，对象是先取方法中的局部变量的值，而不是对象的成员变量的值。在特殊情况下，要把对象的成员变量和方法的局部变量区别出来，这时引进了this关键字。

3、this关键字

this关键字是指当前类的对象引用。简单的记，它就代表当前类的一个对象。解决局部变量隐藏成员变量。

上一案例代码的改进版：（引进了this，更加严谨）
/*     this:哪个对象调用那个方法，this就代表那个对象 */ class Student {     private String name;     private int age;          public String getName() {         return name; //这里其实是隐含了this     }          public void setName(String name) {         this.name = name;     }          public int getAge() {         return age;     }          public void setAge(int age) {         this.age = age;     } } class StudentTest2 {     public static void main(String[] args) {         //创建一个对象         Student s1 = new Student();         s1.setName(“林青霞”);         s1.setAge(27);         System.out.println(s1.getName()+“—”+s1.getAge());                  //创建第二个对象         Student s2 = new Student();         s2.setName(“刘意”);         s2.setAge(30);         System.out.println(s2.getName()+“—”+s2.getAge());     } }

下面，再来看下，通过this关键字，区分调用同名的局部变量和成员变量

区分this.num和num的案例：
class getNum {     private String name;     private int age;     int num=11;  //成员变量     public void show() {         int num=22;  //局部变量         System.out.println("num: "+num);         System.out.println("this.num: "+this.num);     } } class test {     public static void main(String[] args) {         getNum t1 = new getNum();         t1.show();     } } /*  结果是：    num: 22    this.num: 11 */

所以this关键字可以理解为调用的是当前的对象，可以随意调用当前对象任意的成员变量(包括private修饰的，如this.num、this.name和this.age)。以后再写一个类的时候，把所有的成员变量给private了，提供对应的getXxx()/setXxx()方法。

4、static关键字

static关键字实现多个对象有共同的成员变量值的，表静态的，共享的。

4.1、static的特点

/*     static的特点：(它可以修饰成员变量，还可以修饰成员方法)         A:随着类的加载而加载             回想main方法。         B:优先于对象存在         C:被类的所有对象共享             举例：咱们班级的学生应该共用同一个班级编号。             其实这个特点也是在告诉我们什么时候使用静态?                 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。             举例：                 饮水机(用静态修饰)                 水杯(不能用静态修饰)         D:可以通过类名调用             其实它本身也可以通过对象名调用。             推荐使用类名调用。                          静态修饰的内容一般我们称其为：与类相关的，类成员 */ class Student {     //非静态变量     int num = 10;          //静态变量     static int num2 = 20; } class StudentDemo {     public static void main(String[] args) {         Student s = new Student();         System.out.println(s.num);                  System.out.println(Student.num2);         System.out.println(s.num2);     } }

4.2、static关键字的注意事项

学习笔记

主要内容包括html，css，html5，css3，JavaScript，正则表达式，函数，BOM，DOM，jQuery，AJAX，vue等等

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

HTML/CSS

**HTML：**HTML基本结构，标签属性，事件属性，文本标签，多媒体标签，列表 / 表格 / 表单标签，其他语义化标签，网页结构，模块划分

**CSS：**CSS代码语法，CSS 放置位置，CSS的继承，选择器的种类/优先级，背景样式，字体样式，文本属性，基本样式，样式重置，盒模型样式，浮动float，定位position，浏览器默认样式

HTML5 /CSS3

**HTML5：**HTML5 的优势，HTML5 废弃元素，HTML5 新增元素，HTML5 表单相关元素和属性

**CSS3：**CSS3 新增选择器，CSS3 新增属性，新增变形动画属性，3D变形属性，CSS3 的过渡属性，CSS3 的动画属性，CSS3 新增多列属性，CSS3新增单位，弹性盒模型

JavaScript

**JavaScript：**JavaScript基础，JavaScript数据类型，算术运算，强制转换，赋值运算，关系运算，逻辑运算，三元运算，分支循环，switch，while，do-while，for，break，continue，数组，数组方法，二维数组，字符串

tHMG8k-1715825809493)]

JavaScript

**JavaScript：**JavaScript基础，JavaScript数据类型，算术运算，强制转换，赋值运算，关系运算，逻辑运算，三元运算，分支循环，switch，while，do-while，for，break，continue，数组，数组方法，二维数组，字符串

[外链图片转存中…(img-EQ3LprNE-1715825809494)]