一、数组的内容图解
1、内存模型
在通过JVM中的java命令启动JVM之后，首先JVM会在内存中划分5片区域。
- 栈：它的主要功能是负责方法运行。方法进入栈内存（方法压栈），方法执行完出栈（方法弹栈）
- 堆：只要是通过new关键字创建出来的都在堆中，并且堆中的空间必须有初始化默认值。
- 方法区：主要存储class字节码、各种常量池
- 本地方法区：只要运行JVM与系统之间交互等相关的方法
- 寄存器：高速缓存，提供给CPU使用。
2、数组内存图
1
2
3
4
5
6
7
8
9
10
11
12class Demo { public static void main(String[] args) { int x = 123; int[] arr = new int[5]; System.out.println(arr); arr[0] = 1; arr[1] = 11; } }
二、面向对象基础
1、什么是面向对象
面向对象：它是思考问题的方式。在遇到问题（需求）时不要先考虑自己如何去一步一步的实现，而是寻求有没有已经存在的解决方案，复用这些方案达到预期的目标。
面向过程：在实现需求的过程中，自己参与到其中每个步骤。
2、Java中的类和对象
在Java中任何的程序都必须放在类中。
2.1、类
在Java中使用类来封装（描述）生活中的某些事物（个体）。
如果需要用类描述某个群体，需要分析这个群体一些共性的特点：
- 属性：表示群体共性的某个特征值
- 行为：群体共性的一个动作
例如：分析Person
- 属性：年龄、身高、性别等等
- 行为：吃饭、睡觉、打豆豆
分析之后，所有的属性使用变量（定义在类成员位置上）表示，行为使用方法表示。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public class Student { // 年龄 int age; // 姓名 String name; // 成绩 double score; // 学习 public void study() { System.out.println("good good study day day up"); } // 休息 public void sleep() { System.out.println("sleep..........."); } }
2.2、对象
使用class定义了类，需要通过Java中的new 关键字创建出来类的一个实例（个体、对象instance），才能去调用类中定义的属性或行为。
1
2
3
4
5
6
7
8
9
10
11
12
13
14public class StudentTest { public static void main(String[] args) { int x = 123; // 需要使用某个类，必须先new对象 Student s = new Student(); s.age = 23; s.name = "张三"; s.study(); s.sleep(); } }
2.3、类和对象的关系
类：对象抽象的描述，描述群体共性特点的。
对象：类的实例化，基于模板而创建出来最终在程序被使用的。
2.4、对象的内存图
1
2
3
4
5
6
7
8
9
10
11
12public class StudentTest { public static void main(String[] args) { int x = 123; // 需要使用某个类，必须先new对象 Student s = new Student(); s.age = 23; s.name = "张三"; s.study(); s.sleep(); } }
只要基于某个类创建对象，堆内存中会分配这个对象的空间，同时类中的所有的属性（成员变量）都会在当前的对象所在的堆内存中开辟空间。
3、值传递和引用传递区别
1
2
3
4
5
6
7
8
9
10
11
12
13
14public class Test { public static void main(String[] args) { Demo d = new Demo(); System.out.println("d.x =" + d.x); method( d , d.x ); System.out.println("d.x =" + d.x); } public static void method( Demo d , int x ) { x += x; d.x = d.x + 100; } }
方法传递参数：
- 如果传递的具体的数据，那么在方法中有变量接受到这个数据之后，不管在方法中如何去处理这个数据，对原始的变量中的数据没有。
- 如果传递的是数据所在的地址（引用），这是在方法中可以通过地址（引用）去操作指定空间中的数据，会对原始数据产生影响。
4、private关键字
面向对象三大特征：封装、继承、多态。
封装：将不需要外界使用的内容全部隐藏起来，对外只提供部分访问的接口。
Java中封装的体现：
类：本身就是一个封装体，将某个群体属性、行为等进行包裹。然后外界可以通过new对象，去使用类中的属性和行为。
方法：将某些特定功能的代码进行封装，然后再需要的时候调用。
封装：尽可能将所有细节隐藏，需要对外暴露如何使用的接口。
一个类中如果要隐藏不需要外界访问的内容，需要使用权限访问修饰符private。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class Person { private int age; private char sex; // alt + shift + s public int getAge() { return age; } public void setAge(int age) { this.age = age; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } }
类中不需要外界直接访问的内容（变量和方法）都需要被private。
private修饰的变量或方法，只能在本类中使用，类以外的其他程序中都无法直接使用。
如果类中的成员变量被private修饰了，一般都要求针对这些成员变量提供相应的setter或getter方法。
1
2
3
4
5
6
7class Student{ private String name; public void setName( String nm ){ name = nm; } public String getName() { return name; } }
5、构造方法
5.1、构造方法演示
构造方法的定义格式：
1
2
3
4
5修饰符 类名( 数据类型 变量名, 数据类型 变量名,........... ) { 方法体; }
构造方法方法要求：
- 方法名必须和类名一致
- 不能书写任何的返回值类型（void也不行）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24/* * 使用Person表人这类群体，但是实际生活中只要有人存在 * 那么必须会有年龄和性别 */ public class Person { // 表示姓名 private String name; // 性别 private String sex; // 年龄 private int age; // 构造方法 public Person( String nm , String s , int a ) { System.out.println("............"); name = nm; sex = s; age = a; } public void say() { System.out.println("name = " + name + ",age = " + age + ",sex = " + sex); } }
1
2
3
4
5
6
7
8
9public class PersonTest { public static void main(String[] args) { // 创建Person对象 Person p = new Person( "张三" , "男" ,44 ); System.out.println(p); p.say(); } }
5.2、构造方法使用
在创建对象的过程中，如果对象需要明确具体的成员变量的数据，那么就可以通过构造方法完成。
构造方法是在对象new的过程中被JVM调用的。并且将相关参数传递给与之对应的构造方法，进而完成成员变量的赋值操作。
5.3、构造方法练习
需求：描述矩形，提供计算面积的方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20/* * 需求：描述矩形，提供计算面积的方法。 * 分析： * 图形只要被创建，一定会携带一些固有的初始化参数（矩形：长和宽） * */ public class Rectangle { private double width; private double length; public Rectangle( double w , double len ) { width = w ; length = len; } public double getArea() { return width * length; } }
1
2
3
4
5
6
7
8
9
10
11
12/* * 测试类型 */ public class RectangleTest { public static void main(String[] args) { Rectangle r = new Rectangle( 3 , 5 ); double area = r.getArea(); System.out.println(area); } }
5.4、构造方法使用细节
-
构造方法在创建对象过程中执行，对象创建好之后是否可以手动调用构造方法。不可以。因为构造方法只是在构建对象时执行。
-
构造方法的方法名必须与类名一致，那么如果将一个一般的方法名书写为类名会怎样？程序运行存在，这个方法就是一个普通的方法，也可以在创建好对对象之后被调用，但是开发中不建议这么写。
-
一个类中是否可以存在多个构造方法？可以，它们是以重载的形式存在。
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class Rectangle { private double width; private int length; public Rectangle( double w ) { width = w; } public Rectangle( int len ) { length = len; } public Rectangle( double w , int len ) { width = w ; length = len; } }可以保证以不同形式创建出这个类的对象，并进行初始化操作。
-
在构造方法中能不能调用一般的方法？能。直接通过方法名调用。
5.5、默认构造方法
任何一个类如果不手动添加任何的构造方法，在编译之后编译器会自动的给class文件中添加一个空参数的公开的构造方法。
如果一旦人为给类中提交了构造方法，那么编译之后不会再生成默认构造方法。
1
2
3
4
5
6
7
8
9
10
11
12
13public class Student { private String name; private int age; public Student() { } public Student(String nm , int a) { name = nm; age = a; } }
6、this关键字
6.1、this介绍
this：它在程序表示的是一个对象。可以将其理解为一个引用变量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class Student { private String name; private int age; public Student() { System.out.println(this); } public Student(String nm , int a) { name = nm; age = a; } public void say() { System.out.println("say == ==" + this); } }
当某个方法被执行的时候，一定是通过对象调用的，这时方法中有个隐藏的this关键字来记录当前具体调用的那个对象。谁调用方法，this就是谁。
6.2、this的使用场景
- 区分局部变量和成员变量同名 （成员变量：this.变量名 ）
- 调用本类的其他方法 （调用一般法方法：this.方法名( ) ）
- 调用本类的其他构造方法 (调用构造：this( ) )
- 如果通过this调用本类其他构造方法，必须放在构造方法中的第一行。
- 一个类如果有多个构造方法，不能形成嵌套调用。在一个类中肯定有一个构造方法中不会存在this调用别的构造方法。
7、匿名对象
7.1、匿名对象介绍
创建的对象，但是没有赋值给任何的引用。这个对象属于匿名对象。
1
2
3
4
5
6
7
8public class Demo { int x = 12; public void run() { System.out.println("run..... x = " + x); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class Test { public static void main(String[] args) { // d是一个引用变量，存放的Demo对象的地址（引用） Demo d = new Demo(); d.x = 22; // 通过d引用操作对象 d.run(); // 下面直接创建Demo对象，没有将对象的引用赋值给任何变量 // 只要程序执行过去了，当前的对象立刻就变成垃圾 new Demo().x = 33; new Demo().run(); } }
7.2、匿名对象使用场景
-
在方法传递参数的时候，需要一个对象
-
如果类的对象只使用一次，以后不再使用
-
如果程序中大量匿名对象，会导致程序中的垃圾对象变多，匿名对象只要使用结束，就称为垃圾
复制代码1
2
3
4
5
6
7
8
9
10
11
12public class Test { public static void main(String[] args) { method( new Demo() ); new Demo().run(); } public static void method( Demo d ) { } }
7.3、垃圾回收
在JVM中有一个垃圾回收机制gc。它是一个不定时执行的程序，在适当的时间会自动的启动，扫描内存中的垃圾并自动清理。可以通过程序手动的通知垃圾回收机制收垃圾，但是也不一定立刻就收。
1
2System.gc( ) ; // 通知垃圾回收器收垃圾
一般开发中，只关注具体业务实现，垃圾交给JVM处理。
7.4、强制将一个对象变成垃圾
1
2
3
4
5
6
7
8
9
10
11
12
13public class Test3 { public static void main(String[] args) { Demo d = new Demo(); d.x = 123; d.run(); // 其他逻辑 // 将引用赋值给null，引用不再指向任何的对象，对象就成为垃圾 d = null; } }
8、总结
1、分析相关的事物特点，然后总结共性内容
2、使用Java中的类描述这个事物：
事物的属性：使用类中的成员变量表示
事物的行为：使用类中的方法表示
3、通过new关键字创建这个类的对象，调用类中的相关属性或者方法
4、如果一个类的对象在创建过程中需要明确具体的初始化参数，需要给这个类中提供相关的构造方法。
5、类中的所有成员变量应该private，然后提供getXxx或setXxx方法
6、this关键字：1）区分成员变量和局部变量同名；2）调用类中其他方法；3）调用本类其他构造方法
9、思考：
类中已经书写了相关的构造方法，对成员变量进行初始化，那么是否可以省略setXxx方法呢？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22public class Person { private String name; private int age; public void setName(String name) { this.name = name; } public Person(String name, int age) { this.name = name; this.age = age; } public Person() { } public void run() { System.out.println("name = " + name); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14public class Test4 { public static void main(String[] args) { Person p = new Person( "9527" , 11 ); p.run(); // 下面的代码是重新new了一个新的对象，并不是给上面的Person对象改名 //p = new Person( "小书童" , 11 ); //p.run(); p.setName("小书童"); p.run(); } }
构造方法：是在对象创建的时候给成员变量进行初始化操作。
setXxx方法：是在对象已经创建完成（已经存在），然后给成员变量修改数据。
1
2
3
4
5
6
7
8
9
10
11
12
13String name, int age) { this.name = name; this.age = age; } public Person() { } public void run() { System.out.println("name = " + name); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14public class Test4 { public static void main(String[] args) { Person p = new Person( "9527" , 11 ); p.run(); // 下面的代码是重新new了一个新的对象，并不是给上面的Person对象改名 //p = new Person( "小书童" , 11 ); //p.run(); p.setName("小书童"); p.run(); } }
构造方法：是在对象创建的时候给成员变量进行初始化操作。
setXxx方法：是在对象已经创建完成（已经存在），然后给成员变量修改数据。
最后
以上就是单身枕头最近收集整理的关于小白学习JavaSE-day05-类与对象一、数组的内容图解二、面向对象基础的全部内容，更多相关小白学习JavaSE-day05-类与对象一、数组内容请搜索靠谱客的其他文章。
发表评论 取消回复