概述
一、数组的内容图解
1、内存模型
在通过JVM中的java命令启动JVM之后，首先JVM会在内存中划分5片区域。
- 栈：它的主要功能是负责方法运行。方法进入栈内存（方法压栈），方法执行完出栈（方法弹栈）
- 堆：只要是通过new关键字创建出来的都在堆中，并且堆中的空间必须有初始化默认值。
- 方法区：主要存储class字节码、各种常量池
- 本地方法区：只要运行JVM与系统之间交互等相关的方法
- 寄存器：高速缓存，提供给CPU使用。
2、数组内存图
class 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
- 属性：年龄、身高、性别等等
- 行为：吃饭、睡觉、打豆豆
分析之后，所有的属性使用变量（定义在类成员位置上）表示，行为使用方法表示。
public 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），才能去调用类中定义的属性或行为。
public 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、对象的内存图
public 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、值传递和引用传递区别
public 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。
public 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方法。
class Student{
private String name;
public void setName( String nm ){ name = nm; }
public String getName() { return name; }
}
5、构造方法
5.1、构造方法演示
构造方法的定义格式：
修饰符 类名( 数据类型 变量名, 数据类型 变量名,........... )
{
方法体;
}
构造方法方法要求：
- 方法名必须和类名一致
- 不能书写任何的返回值类型（void也不行）
/*
* 使用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);
}
}
public 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、构造方法练习
需求：描述矩形，提供计算面积的方法。
/*
* 需求：描述矩形，提供计算面积的方法。
* 分析：
* 图形只要被创建，一定会携带一些固有的初始化参数（矩形：长和宽）
*
*/
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;
}
}
/*
* 测试类型
*/
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、构造方法使用细节
-
构造方法在创建对象过程中执行，对象创建好之后是否可以手动调用构造方法。不可以。因为构造方法只是在构建对象时执行。
-
构造方法的方法名必须与类名一致，那么如果将一个一般的方法名书写为类名会怎样？程序运行存在，这个方法就是一个普通的方法，也可以在创建好对对象之后被调用，但是开发中不建议这么写。
-
一个类中是否可以存在多个构造方法？可以，它们是以重载的形式存在。
public 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文件中添加一个空参数的公开的构造方法。
如果一旦人为给类中提交了构造方法，那么编译之后不会再生成默认构造方法。
public 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：它在程序表示的是一个对象。可以将其理解为一个引用变量。
public 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、匿名对象介绍
创建的对象，但是没有赋值给任何的引用。这个对象属于匿名对象。
public class Demo {
int x = 12;
public void run() {
System.out.println("run..... x = " + x);
}
}
public 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、匿名对象使用场景
-
在方法传递参数的时候，需要一个对象
-
如果类的对象只使用一次，以后不再使用
-
如果程序中大量匿名对象，会导致程序中的垃圾对象变多，匿名对象只要使用结束，就称为垃圾
public class Test { public static void main(String[] args) { method( new Demo() ); new Demo().run(); } public static void method( Demo d ) { } }
7.3、垃圾回收
在JVM中有一个垃圾回收机制gc。它是一个不定时执行的程序，在适当的时间会自动的启动，扫描内存中的垃圾并自动清理。可以通过程序手动的通知垃圾回收机制收垃圾，但是也不一定立刻就收。
System.gc( ) ; // 通知垃圾回收器收垃圾
一般开发中，只关注具体业务实现，垃圾交给JVM处理。
7.4、强制将一个对象变成垃圾
public 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方法呢？
public 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);
}
}
public 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方法：是在对象已经创建完成（已经存在），然后给成员变量修改数据。
String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
public void run() {
System.out.println("name = " + name);
}
}
public 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-类与对象一、数组的内容图解二、面向对象基础所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复