笔记|二、对象与类、封装、构造方法面试|开发语言|java

??戳我跳到个人主页
??本人码云（建议pc端打开，手机可能会出现字体过小问题。)
??本人会不定期在码云上更新一些算法或数据结构的基础程序，后期也会学习进阶程序，也会更新大厂的面试题。
??如果您有好的建议和想法，欢迎在本人码云相应代码评论区评论哦。希望大家都能在编程这条路上越走越远。也祝看到这篇博客的人，能真正搞懂这方面知识，当然，若有错误，请提出改正，谢谢大家啦。
??本人后续会在这里更新操作系统和计组的笔记，敬请期待！
??有赞必回，评论必回，顺着网线回访！

二、对象与类、封装、构造方法

1.Java类1
- （1）引入
- （2）定义
- （3）对象的创建及使用
- （4）Student.java、Phone.java
- （5）Phone类练习
- （6）自定义类作为方法的参数
- （7）自定义类作为方法返回值
- （8）局部变量、成员变量
2.Java类2
- （1）面向对象之封装性
- （2）private关键字
- （3）this关键字
- （4）构造方法
- （5）练习、定义一个标准的类JavaBean
- （6）匿名对象
- （7）匿名对象作为方法参数或返回值
- （8）Object类
2.1对象实例化分析！
3.静态static关键字
- （1）概述
- （2）静态static关键字修饰成员变量
- （3）静态static的内存图
- （4）静态static关键字修饰成员方法
- （5）静态代码块
4.再谈main方法

1.Java类1 （1）引入 【笔记|二、对象与类、封装、构造方法】/*
?（一）面向对象与面向过程
???–面向过程：当需要实现一个功能时，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

???–面向对象：当需要实现一个功能时，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。
*/

package packone; import java.util.Arrays; public class Face01 { 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.print(Arrays.toString(array)); } }

文章图片

（2）定义 ?（二）面向对象三大特征

封装
继承
多态
??~所有面向对象的编程语言都有这三大特征。
??~C++半面向对象，Java纯面向对象。
???采用面向对象的方式开发一个软件，生命周期当中。
??~面向对象的分析：OOA
???????设计：OOD
??????? 编程：OOP

?（三）类和对象
3.1类：是一组相关属性和行为的集合。
???可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
???--现实中，描绘一类事物：
???属性：该事物的状态信息；
???行为：该事物能做什么。
??–举例，猫。
????–属性：名字，体重，年龄，颜色；
????–行为：走，跑，叫。
3.2对象：是一类事物的具体表现。
??? 对象是类的一个实例，具备该类某种属性和行为。
???--现实中，一类事物的一个实例：李娜家的猫。
????–属性：tom，5kg，2years，yellow。
????–行为：溜墙根走，蹦跶的跑，喵喵叫。
3.3类与对象的关系

类是对一类事物的描述，是抽象的。
对象是一类事物的实例，是具象的。
类是对象的模板，对象是类的实体。

?（四）类的定义
4.1现实世界的一类事物
???--属性：事物的状态信息；
???--行为：事物能够做什么。
?Java中用class描述事物也是如此：
???–成员变量：对应事物的属性；
???–成员方法：对应事物的行为。
4.2类的定义格式

public class 类名{ //成员变量 //成员方法 }

??定义类：就是定义类的成员，包括变量和方法。

??成员变量：在类中，方法外。
??成员方法：去掉static。

4.3见Student.java！！！
java中所有的.class文件都是引用数据类型！
（3）对象的创建及使用 /*
（五）对象的创建和使用
5.1
–通常情况下，一个类并不能直接使用，
–需要根据类创建一个对象，才能使用。
5.2过程
??5.2.1导包
????--也就是指出需要使用的类，在什么位置。
?????import 包名称.类名称；
????--对于和当前类属于同一个包的情况，可以省略导包语句。
??5.2.2创建，格式

????–类名称对象名 = new 类名称 () ;
????–Student stu = new Student () ;

??5.2.3使用，分为两个情况
????--使用成员变量：对象名 . 成员变量名；
????--使用成员方法：对象名 . 成员方法名(参数)。
*/
（4）Student.java、Phone.java

定义一个类，模拟“学生”事物。

成员变量（属性）：
??姓名 ?

String name ;

??年龄 ?

int age ;

成员方法（行为）：
??吃饭? public void eat () {}
??睡觉? public void sleep () {}
??学习? public void study () {}
?注意事项：
?1、成员变量是直接定义在类当中的，在方法外边。
?2、成员方法不要写static关键字。

package packone; public class Student { String name = "Lee"; int age = 21; public void eat(){ System.out.println("吃饭喽！"); } public void sleep(){ System.out.println("睡觉喽！"); } public void study(){ System.out.println("学习喽！"); } }

定义一个类，模拟手机事物。

成员变量（属性）：
??品牌 ?

String brand ;

??价格 ?

double price ;

??颜色 ?

String color ;

成员方法（行为）：
??打电话? public void call ( String who ) {}
??群发短信?public void sendMessage () {}

package packone; public class Phone { String brand; double price; String color; public void call( String who ){ System.out.println("给"+who+"打电话"); } public void sendMessage(){ System.out.println("群发短信"); } }

（5）Phone类练习

package packone; public class Demo00Phone { public static void main(String[] args) { Phone one = new Phone(); System.out.println(one.brand); System.out.println(one.price); System.out.println(one.color); one.call("佐助"); System.out.println("============"); one.brand = "RedmiK20Pro"; one.price = 2499.9; one.color = "鎏金红黑色"; System.out.println(one.brand); System.out.println(one.price); System.out.println(one.color); one.call("雷军"); }}

文章图片

（6）自定义类作为方法的参数

package packone; public class Demo01Phone { 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); }}

文章图片

（7）自定义类作为方法返回值

package packone; public class Demo02Phone { 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; } }

文章图片

（8）局部变量、成员变量一、概念
定义一个类：

public class { //成员变量 //成员方法 }

局部变量：
局部变量,也称内部变量,是指在一个函数内部或复合语句内部定义的变量。
二、区别
1、定义的位置不同【重点】
局部变量：在方法的内部；
成员变量：在方法的外部，直接写在类当中。
2、作用范围不同【重点】
局部变量：只有方法体中才可以使用，出了方法就不能使用；
成员变量：整个类都可以通用。
3、默认值不同【重点】
局部变量：没有默认值；
成员变量：有默认值。
4、内存位置【了解】

局部：位于栈；
成员：位于堆。

5、生命周期【了解】
局部：随着方法进栈而诞生，随着方法出栈而消失；
成员：随着对象创建而诞生，随着对象被垃圾回收而消失。

package packone; public class Test凌凌漆 { String name; //成员变量 public void methodA() { int num = 20; System.out.println( num ); System.out.println( name ); } public void methodB( int tiger ) { //参数在方法调用时，必然会被赋值System.out.println( tiger ); //编译正确 int age; System.out.println( age ); //编译错误，无初值 } }

2.Java类2 （1）面向对象之封装性封装性在Java中的体现
——封装就是将一些细节信息隐藏起来，对于外界不可见
1、方法就是一种封装

package packone; public class 封装性之方法 { //java封装性——方法 public static void main(String args[]) { int [] array = { 5, 15, 20, 25, 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; } }

getMax方法中也可以用while循环，作用一致就没有影响。

关键字private也是一种封装
Person类

package packone; /* 问题描述：定义Person的年龄时，无法检验数字是否有意义，比如0岁或负岁。解决：用private关键字将需要保护的成员变量进行修饰。一旦使用prinvate关键字，本类中可以直接访问一旦出了本类，不可直接访问。 */ public class Person { String name; //姓名 private int age; //年龄 public void show(){ System.out.println("我叫："+ name + "，年龄："+ age ); } }

应用类

package packone; public class Demo01Person { public static void main(String[] args) { Person me = new Person(); me.show(); me.name = "彭于晏"; me.age = 18; //报错！！！ me.show(); }}

思考：如何才能让我们既可以保护需要被保护的变量，又可以能简洁的访问到它？

稍作修改：

package packone; /* 问题描述：定义Person的年龄时，无法检验数字是否有意义，比如0岁或负岁。解决：用private关键字将需要保护的成员变量进行修饰。一旦使用prinvate关键字，本类中可以直接访问一旦出了本类，不可直接访问。间接访问private成员变量，定义Getter和Setter方法。对于Getter来说，不能有参数，返回值类型和成员变量对应；对于Setter来说，不能有返回值，参数类型和成员变量对应。 */ public class Person { String name; //姓名 private int age; //年龄 public void show(){ System.out.println("我叫："+ name + "，年龄："+ age ); } //这个成员方法，专门用于设置age的值 public void setAge(int num){ if ( num < 100 && num >= 0 ) age = num; else System.out.println("数据不合理"); } //这个成员方法，专门用于获取age的值 public int getAge(){ return age; } }

应用：

package packone; public class Demo01Person { public static void main(String[] args) { //java封装性——private关键字 Person me = new Person(); me.show(); me.name = "彭于晏"; me.setAge(-20); me.show(); me.setAge(70); me.show(); } }

文章图片

（2）private关键字 Dog类

package packone; public class Dog { private String name; private String color; private int age; //name的两个方法 public void setName(String mingzi){ name = mingzi; } public String getName(){ return name; } //color的两个方法 public void setColor(String yanse){ color = yanse; } public String getColor(){ return color; } //age的两个方法 public void setAge(int num){ age = num; } public int getAge(){ return age; } //定义两个方法 public void run(String action){ System.out.println(name+action+"着跑"); } public void eat(int boal){ System.out.println(name+"一顿可以吃"+boal+"碗饭"); } //这是在本类中调用了私有成员变量，没有问题。 //但是如果出了这个类，就必须使用get和set方法。}

Demo01Dog类

package packone; public class Demo01Dog { public static void main(String[] args) { //Dog类中 private 关键字的练习 Dog p = new Dog(); p.setName("皮皮"); p.eat(4); p.setAge(2); System.out.println( p.getName() + "今年" + p.getAge() + "岁" ); p.setColor("黑棕"); System.out.println( p.getName() + "是" + p.getColor() + "颜色"); p.run("跳"); }}

文章图片

补充：对于 boolean 型的成员变量，Getter 方法一定要写成 isXXX 的形式，Setter 方法形式不变。
（3）this关键字

??当方法的局部变量和类的成员变量重名时，根据 “就近原则”，优先使用局部变量。
?? 如果需要访问本类中的成员变量，需要使用格式：
????????????????????? ???this.成员变量名
??“ 通过谁调用的方法，谁就是 this ”

package packtwo; public class Person { String name; //我自己的名字 //this.name是成员变量，我自己的名字 public void sayHello( String name ){ System.out.println(name+",Hi.I'm" + this.name + "."); //上面这两个 name 是同一个 name System.out.println(this); //per的地址值 } }

应用类：

package packtwo; //在这个代码中：this.name 等价于 per.namepublic class Demo01Person { public static void main(String[] args){ Person per = new Person(); per.name = "Jamie Lannister"; //我 per.sayHello("John Snow"); //朋友 System.out.println(per); //per 的地址值 } }

文章图片

（4）构造方法

构造方法：构造方法是专门用来创建对象的方法，当我们通过关键字 new 来创建对象时，其实就是在调用构造方法。格式： public 类名称 ( 参数类型参数类型 ) { //方法体 }注意事项： 1、构造方法的名称必须和类名称保持完全一致； 2、构造方法不要写返回值类型，连void都不要； 3、如果没有编写任何构造方法。那么编译器会默认赠送一个构造方法，没有参数，方法体什么事情都不做； 4、一旦编写了至少一个构造方法，那么编译器将不再赠送； 5、构造方法也是可以进行重载的。重载：方法名称相同，参数列表不同。

Student类

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; } //Setter、Getter方法 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; } }

Demo02Student类

package packtwo; public class Demo02Student { public static void main(String[] args) { Student stu1 = new Student(); //无参构造 System.out.println("============="); Student stu2 = new Student("皮皮虾", 19); //全参构造 System.out.println("姓名:" + stu2.getName() + "年龄:" + stu2.getAge()); //如果需要改变对象当中的成员变量的数据内容，仍然需要使用Setter方法 stu2.setAge(20); System.out.println("姓名:" + stu2.getName() + "年龄:" + stu2.getAge()); } }

文章图片

（5）练习、定义一个标准的类JavaBean 四个部分：
1、成员变量用 private 关键字修饰；
2、为每一个成员变量编写 Getter, Setter 方法；
3、编写一个无参数的构造方法；
4、编写一个全参数的构造方法。

package packtwo; public class Teacher { //成员变量 private String name; //姓名 private String major; //专业 private int age; //年龄 private boolean male; //性别 //无参构造方法 public Teacher(){ System.out.println("无参构造方法执行了"); } //全参构造方法 public Teacher( String name, String major, int age, boolean male ){ System.out.println("全参构造方法执行了"); this.name = name; this.major = major; this.age = age; this.male = male; } //Setter 和 Getter 方法 public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setMajor(String major){ this.major = major; } public String getMajor(){ return major; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } public void setMale(boolean male){ this.male = male; } public boolean isMale(){ return male; } }

使用这个标准的老师类

package packtwo; public class Demo01Teacher { public static void main(String[] args) {Teacher one = new Teacher(); one.setName("One"); one.setMajor("Computer"); one.setMale(true); System.out.println("姓名" + one.getName() + "专业" + one.getMajor() + "，岁数" + one.getAge() + "性别" + one.isMale() ); System.out.println("========================"); Teacher two = new Teacher("Two", "English", 28, false ); System.out.println("姓名" + two.getName() + "专业" + two.getMajor() + "，岁数" + two.getAge() + "性别" + two.isMale() ); } }

文章图片

（6）匿名对象

定义：
创建对象的标准格式：
类名称对象名 = new 类名称() ;
匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
注意事项：匿名对象只能使用一次，下次必须创建新的。

例： new Person(); new Person().name = "李"; 这是两个不同的匿名对象

Dog类

package pack03; public class Dog { String name; public void show(String name) { this.name = name; System.out.println("你们好，我叫：" + name ); } }

应用类

package pack03; public class DemoDog { public static void main(String[] args) { //左边的 one 就是对象的名字 Dog one = new Dog(); one.show(); //匿名对象 new Dog().name = "joe"; new Dog().show("marry"); System.out.println("这是两个不同的匿名对象"); } }

文章图片

（7）匿名对象作为方法参数或返回值

package pack03; import java.util.Scanner; public class Demo { public static void main(String[] args) { //【1】普通使用方式 //Scanner s = new Scanner(System.in); //int num = s.nextInt(); //【2】匿名对象的方式 //int num = new Scanner(System.in).nextInt(); //System.out.println("输入的是" + num ); //【3】使用一般方法传入参数 //Scanner s = new Scanner(System.in); //method(s); //使用匿名对象来进行传参 //method(new Scanner(System.in)); //匿名对象作为方法返回值 Scanner s = method2(); int num = s.nextInt(); System.out.println("输入的是" + num ); } public static void method(Scanner s){ int num = s.nextInt(); System.out.println("输入的是：" + num ); } public static void method2(){ //Scanner s = new Scanner(System.in); //return s; return new Scanner(System.in); } }

文章图片

（8）Object类

【1】Object类是所有Java类的根父类；【2】如果在类的声明中未使用extends关键字指明，默认是Object类；【3】多层继承中，Object一定是最高等级的类；【4】Object类可以适用于所有的类的类型，与所有的类都是继承关系；【5】子类可以执行父类的方法。

2.1对象实例化分析！

1.静态变量用static修饰的变量 2.静态初始化块 static{}圈起来的初始化块 3.静态方法用static修饰的方法 4.变量 5.初始化块 6.构造器 7.普通方法

父类(静态域按顺序加载)–>子类(静态域按顺序加载)–> 父类(非静态变量,非静态代码块,构造函数)–>子类(非静态变量,非静态代码块,构造函数) 静态域：静态变量和静态块

3.静态static关键字（1）概述

文章图片

（2）静态static关键字修饰成员变量 ??如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，
而是属于所在的类，多个对象共享一个成员变量。
??类名称.变量名，就可以表示这个成员变量。
Student类

package pack05; public class Student { private int id; //学号 private String name; //姓名 private int age; //年龄 static String room; //教室 private static int idCounter = 0; //学号计数器 //每当 new 了一个新对象时，计数器＋＋ //构造方法 //========== public Student(){ this.id = ++ idCounter; } public Student(String name, int age){ this.name = name; this.age = age; this.id = ++ idCounter; } //Setter, Getter方法 //========== 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 int getId(){ return id; } }

DemoStu应用类

package pack05; public class DemoStu { public static void main(String args[]){ Student one = new Student("郭靖", 19); one.room = "101教室"; //room是静态变量，属于类 System.out.println("姓名：" + one.getName() + "年龄：" + one.getAge()); System.out.println("教室：" + one.room + "学号：" + one.getId()); Student two = new Student("黄蓉", 16); //郭靖和黄蓉应该在同一间教室 System.out.println("姓名：" + two.getName() + "年龄：" + two.getAge()); System.out.println("教室：" + two.room + "学号：" + two.getId()); //每次都要写这么多很麻烦！后面会介绍一个方法写出这些属性 }}

文章图片

（3）静态static的内存图郭靖、黄蓉为例：

文章图片

（4）静态static关键字修饰成员方法一、定义：
一旦使用了static关键字进行修饰成员方法，那么这就成为了静态方法，
静态方法不属于对象，而属于所处的类。
【1】没有static关键字的方法，用对象名.方法名; （普通方法）
【2】有static关键字的方法，用类名.方法名。（静态方法）
二、注意事项：
1、静态不能直接访问非静态。（方法、变量）
原因：因为在内存中是[先]有的静态内容，[后]有的非静态内容。
“先人不知道后人，后人知道先人”
2、静态方法体中不能用this.
原因：
this代表当前对象，通过谁调用的方法，谁就是当前对象，但是，静态与对象无关。
三、代码截图
Myclass类：

文章图片

DemoMyClass类：

文章图片

（5）静态代码块一、静态代码块的格式是：

public class 类名称 { static { 静态代码块的内容 } }

二、特点：
【1】当第一次用到本类时，静态代码块执行唯一的一次；
【2】静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
三、静态代码块用途：
用来一次性地对静态成员变量进行赋值。

package pack05; public class Person { //静态代码块 static { System.out.println("静态代码执行！"); } //无参构造方法 public Person(){ System.out.println("构造方法执行！")； } }