JAVA面向对象01

面向对象
- 自定义类
- 构造方法
- this关键字
- static关键字
- block关键字
- Debug调试工具

面向对象

面向对象和面向过程的区别:

面向过程:

关注"我应该如何实现?"按照步骤一步一步实现就可以了

面向对象:

关注"我应该找谁来完成?"这个谁就是对象,对象如何完成不关注

面向对象依赖面向过程

面向对象思想的好处:

1.更符合显示生活中人们的思维

2.面向对象更贴合管理者的思维角度,面向过程更贴合执行者的思维角度

3.面向对象可以将复杂的问题简单化

如何使用面向对象进行编程:

就是要让程序与现实生活紧密联系

两个概念:

类:定义一系列事物的共性->图纸|模板|模具

对象:表示现实生活中的具体事物–>实例

根据类构建对象,因为先有图纸才能造车

自定义类

自定义的类也是引用数据类型

分析步骤:

一个事物具有的功能—>成员方法

一个事物具有的属性—>成员变量

模板:

            public class 类名{               //成员变量--->属性                修饰符 数据类型 变量名 = 赋值;                //成员方法--->功能                修饰符 返回值类型|void 方法名(参数列表){                          方法体;                       }              }

使用自定义类:

1.导包

不需要导包的类

1)同包下的类

2)java.lang包下的内容不需要导包

2.创建当前引用数据类型的变量|应用–>创建对象

引用数据类型引用 = new引用数据类型(); //new 关键字具有创建对象的能力

3.使用成员

成员变量引用.成员变量名

成员方法引用.成员方法名(参数列表);

注意:

成员变量不赋值存在默认值:整型->0 浮点型->0.0 boolean->false char->’ ’ 引用数据类型 -> null

成员(变量|方法)是属于对象的,必须跟随对象进行使用

成员位置:类中方法外就是成员位置

一个方法的参数类型与返回值类型都可以为自定义的引用数据类型

public class StudentTest {public static void main(String[] args) {Student student1 = new Student();student1.name = "小明";student1.age = 18;student1.score = 100;Student student2 = new Student();student2.name = "小宏";student2.age = 20;student2.score = 90;student1.info();student1.study(student1);student1.info();student2.info();Student student3 = student2.play(student2);student3.info();}
}class Student{public String name;public int score;public int age;public void study(Student student){int score = student.score;    //student.score指的是作为实参传入的对象中的score    //int score是在study方法中声明的局部变量,只在study方法中有效student.score  += 10;System.out.println(student.name+"通过努力学习,成绩从"+score+"提升到了"+student.score);}public void info(){System.out.println("学生姓名:"+name+"\n学生年龄:"+age+"岁\n学生成绩:"+score+"分");}//自定义方法可以传入自定义类型的引用变量,也可以返回自定义类型的引用变量public Student play(Student student){int score = student.score; //student.score指的是作为实参传入的对象中的score    //int score是在study方法中声明的局部变量,只在study方法中有效student.score  -= 10;System.out.println(student.name+"经常玩耍,成绩从"+score+"下降到了"+student.score);return student;}
}

构造方法

new 关键字做的三件事情:

1.堆中为对象开辟内存空间,成员变量跟随对象进入到堆内存,附默认值

2.调用构造器为对象初始化信息

3.对象的地址返回给引用

构造器|构造方法|构造函数:

特殊的方法

作用: 为对象初始化信息(为对象的成员变量赋值)

使用: 只能跟随new一起使用

定义:

    修饰符  类名(参数列表){        ....
    }

构造器的名字要求与类名保持一致

构造器不需要返回值,不能定义void

可以定义return,作用就是提前结束方法

构造器: 可以实现在创建对象的同时为对象的成员变量赋值

如果没有显示定义构造器,编译器会默认提供一个空构造(没有参数的构造器)

如果存在显示定义的构造器,编译器不会为提供任何构造器包括空构造

注意:

至少为自定义的模板类提供一个空构造

public class StudentTest {public static void main(String[] args) {Student student1 = new Student();student1.info();student1.name = "小明";student1.age = 18;student1.score = 100;//可以使用构造方法,在new时对对象中的属性进行第一次赋值Student student2 = new Student("小宏",20,90);student1.info();student1.study(student1);student1.info();student2.info();}
}class Student{public String name;public int score;public int age;public Student(){//空构造方法,如果类中一个构造方法都没有,编译器会自动创建一个空构造方法,如果存在空构造或者带参数的构造方法,则不会再自动创建空构造}//构造方法是特殊的方法,构造方法只在new时被调用一次,构造方法可以重载public Student(String name,int age,int score){this.name = name;this.age = age;this.score = score;}public void study(Student student){int score = student.score;student.score  += 10;System.out.println(student.name+"通过努力学习,成绩从"+score+"提升到了"+student.score);}public void info(){System.out.println("学生姓名:"+name+"\n学生年龄:"+age+"岁\n学生成绩:"+score+"分");}
}

this关键字

代表当前对象(当前new的对象),存储对象的地址

1.能够在构造器的首行用来调用本类中的其他构造器this(参数列表);

2.用来区分成员与局部同名的问题

如果出现同名问题,默认就近原则

如果出现同名问题,想要代指调用同名的成员,需要this.成员调用

不存在同名问题,指代成员的时候,this.可以省略

this在构造器中默认指代当前new的对象

this在成员方法中,默认指代当前调用成员方法的对象

注意:

构造器可以调用其他重载的构造器,不能相互调用

在被static修饰的方法中不能使用this

public class StudentTest {public static void main(String[] args) {Student student = new Student("小明",20,100);student.info();//将student对象中score属性+10student.study();student.info();}
}class Student{public String name;public int score;public int age;public Student(){System.out.println("空构造方法被调用");//空构造方法,如果类中一个构造方法都没有,编译器会自动创建一个空构造方法,如果存在空构造或者带参数的构造方法,则不会再自动创建空构造}//构造方法是特殊的方法,构造方法只在new时被调用一次,构造方法可以重载//形参变量名和需要被赋值的成员变量名相同,使用this.变量名表示该变量为当前对象中的成员变量public Student(String name,int age,int score){this(); //调用当前对象中的空构造方法this.name = name;this.age = age;this.score = score;}public void study(){//作为实参被传入的Student类型的对象的score属性赋值给方法中的score变量,两个变量同名,就需要使用this.score表示该变量为student对象中的scoreint score = this.score;this.score  += 10;System.out.println(this.name+"通过努力学习,成绩从"+score+"提升到了"+this.score);}//info方法中没有同名变量,name,age,score默认指代当前对象中的name,age,score成员变量,省略了this.public void info(){System.out.println("学生姓名:"+name+"\n学生年龄:"+age+"岁\n学生成绩:"+score+"分");}
}

static关键字

static 静态的

static是成员的修饰符,只能修饰成员,不能修饰局部

应用场景比如:工具类:jdk封装,自己封装…Math,Arrays…,一般为静态工厂,简单,方便用户使用

成员的位置:定义在类中方法外

成员变量:

不被static修饰的成员变量 --> 成员变量|实例变量

被static修饰的成员变量 -->静态变量|类变量

一个类中多个对象共享的,内容是独一份的,可以是使用静态变量声明,静态变量被改变时,所有使用到静态变量的对象中的静态变量都会被改变

成员方法:

不被static修饰的成员方法 --> 成员方法|实例方法

被static修饰的成员方法 --> 静态方法|类方法

使用:

1.通过对象的引用调用

引用.静态变量名

引用.静态方法名(参数列表)

2.通过类名调用

类名.静态变量名

类名.静态方法名(参数列表)

static可以用来修饰块和类,被static修饰的是属于类的,可以被类名调用也可以被对象的引用调用;(成员)不被static修饰的是属于对象的,只能被对象的引用调用

静态内容是独一份的,在类第一次加载完成之后就进行初始化,仅初始化一次,加载的内容是先静态后成员

静态方法不能使用this,因为静态方法可以通过类名调用,在调用时可以不存在对象,所以不允许使用

public class StudentTest {public static void main(String[] args) {//使用类名调用静态变量,此时不存在对象System.out.println(Student.school);//new一个对象Student st = new Student("小明",20,100);//使用对象的引用调用静态变量System.out.println(st.school);//使用对象的引用调用成员变量System.out.println(st.name);st.info();st.study();st.info();}
}class Student{public String name;public int score;public int age;public static String school = "清华大学";public Student(){System.out.println("空构造方法被调用");//空构造方法,如果类中一个构造方法都没有,编译器会自动创建一个空构造方法,如果存在空构造或者带参数的构造方法,则不会再自动创建空构造}//构造方法是特殊的方法,构造方法只在new时被调用一次,构造方法可以重载//形参变量名和需要被赋值的成员变量名相同,使用this.变量名表示该变量为当前对象中的成员变量public Student(String name,int age,int score){this(); //调用当前对象中的空构造方法this.name = name;this.age = age;this.score = score;}public void study(){//作为实参被传入的Student类型的对象的score属性赋值给方法中的score变量,两个变量同名,就需要使用this.score表示该变量为student对象中的scoreint score = this.score;this.score  += 10;System.out.println(this.name+"通过努力学习,成绩从"+score+"提升到了"+this.score);}//info方法中没有同名变量,name,age,score默认指代当前对象中的name,age,score成员变量,省略了this.public void info(){System.out.println("学生姓名:"+name+"\n学生年龄:"+age+"岁\n学校:"+school+"\n学生成绩:"+score+"分");}
}

block关键字

{} 自成作用域

定义位置执行时机

{} 定义在方法中或者语句块中 --> 局部代码块|普通语句块所在方法调用时候

{} 定义在类中方法外 -->构造块创建对象的时候

static {} 定义在类中方法外 --> 静态块类加载

构造块中的代码在编译期间会被编译到要执行的构造器代码上面,所以构造块代码在构造器代码之前执行

如果存在多个构造块,从上到下依次执行

在类第一次加载完成之后,就执行,并且只执行一次

如果存在多个静态块,从上到下依次执行

执行顺序: 静态变量–>静态块->主方法–>new–>对应的构造器(空构造)–>构造块->构造器

作用:

静态块: 一般作为一些数据的加载,配置…在类加载完成之后就执行,并且只执行一次,后续不能调用,不需要调用

可以为静态内容做初始化操作

构造块: 一般也是为对象的成员初始化

局部代码块:

自成作用域

具有语义化特点:使代码结构更清晰,可以说明该段代码的用途和开始结束的范围

public class Demo{public static void main(String[] args) {//DemoClass类首次被加载,执行了静态块System.out.println(DemoClass.num);//DemoClass类被实例化时,调用构造方法,在最后一个构造方法执行前,先执行了构造块DemoClass dc = new DemoClass();}
}class DemoClass{static {System.out.println("这是静态块1");}static {System.out.println("这是静态块2");}static public int num = 10;public DemoClass(){this(1);System.out.println("这是一个空构造方法");}{System.out.println("这是构造块");}public DemoClass(int a){System.out.println("这是一个有参数的构造方法");}}/*
输出为:这是静态块1
这是静态块1
10
这是构造块
这是一个有参数的构造方法
这是一个空构造方法编译为class文件后,会发现构造块中的代码被放在了最后一个被调用的构造方法内的代码前,如:public DemoClass(){this(1);System.out.println("这是一个空构造方法");}public DemoClass(int a){System.out.println("这是构造块");System.out.println("这是一个有参数的构造方法");}
*/

Debug调试工具

作用:

1.追踪程序的执行流程

2.定位异常的位置

3.查看程序执行过程中变量的变化情况

4.根据程序的执行过程学习第三方框架的源码

使用:

1.设置断点 (当程序执行到断点所在位置,会进入到debug调试窗口,后面的每一行语句的执行由程序猿控制)

在行号的后面点击一下设置断点,点一下取消断点

2.debug模式下运行
step over F8 下一步跳过下一步有方法的调用也不进入,不跟随执行,直接执行下一行

step into F7 步入下一步下一步如果是自定义方法的调用,进入跟随执行,jdk提供的类库中的方法的调用,不进入

Force step into alt+shift+F7 强制步入下一步下一步如果是自jdk提供的类库中的方法的调用,强制进入跟随执行

step out shift+F8 下一步调出方法的调用,直接结束调用执行进入下一步

Run to cursor alt+F9 跳到光标所在位置继续执行

初识JAVA07:自定义类、构造方法、this关键字、static关键字、block关键字、Debug调试工具相关推荐

Java 主函数 main 中的关键字 static
相信很多人在运行第一个可以运行的 Java 程序的时候都会要求写一个主函数. 然后很多人都会照葫芦画瓢的写一个下面的函数: public static void main(String[] args) ...
Java-Day11 面向对象遍程的入门 (类属性的默认值、构造方法、类的成员、static关键字、类的成员加载顺序、Java(权限)访问修饰符)
目录 1. 类的属性的默认值问题 2. 构造方法(Constructor) 3. 类的成员 3.1 类的成员之一:属性 3.2 UML类图 4. static关键字 5. 类的成员加载(运行)顺序 6 ...
7 面向对象(成员变量和局部变量的区别,类作为形式参数的问题,匿名对象,封装,private关键字,this关键字,构造方法,类的初始化过程,static关键字)
1:成员变量和局部变量的区别(理解) (1)在类中的位置不同成员变量:类中方法外局部变量:方法定义中或者方法声明上 (2)在内存中的位置不同成员变量:在堆中局部变量:在栈中 (3)生命周期不同 ...
JAVA类和对象（构造方法、方法重载、this关键字）
Java是一门完全面向对象的编程语言:类和对象是面向对象编程的基础和核心. 面向对象的编程思想是来源于现实生活:面向对象编程是使用代码来模拟现实生活中的场景. 1.现实生活中有哪些是对象? 对象:在现 ...
Java查漏补缺（08）关键字:static、单例设计模式、理解main方法、类的成员之四:代码块、final关键字、抽象类、接口、内部类、枚举类、注解、包装类
Java查漏补缺(08)关键字:static.单例设计模式.理解main方法.类的成员之四:代码块.final关键字.抽象类.接口.内部类.枚举类.注解.包装类本章专题与脉络 1. 关键字:stat ...
【JavaLearn】 # （2）类和对象、变量、构造方法、普通方法、this关键字
1. 类和对象 1.1 面向过程和面向对象面向过程和面向对象都是对软件分析.设计和开发的一种思想. 机器语言汇编语言高级语言面向过程:C.Fortran... 面向对象:C++.Java.C# ...
学习-Java类和对象之static关键字之求圆环面积和周长
任务描述本关任务:已知圆环的大圆半径 R 和小圆半径 r 的长度分别为 32.0 和 10.0,求该圆环的面积和周长. 圆环面积公式为:S=π(R2−r2): 圆环周长公式为:C=2π(R+r). ...
Spring Boot——自定义Web配置类后无法访问/static文件夹下静态资源
问题描述自定义Web配置类后无法访问 /static文件夹下静态资源. 已加相关依赖包. 官方文档 Spring MVC Auto Configuration Maven <dependenc ...
C++类的静态数据成员-关键字static
C++类的静态数据成员-关键字static 定义:用static关键字声明的数据成员称为静态数据成员. 每个类只有一个存储单元,静态数据成员为该类的所有对象共有,不属于某个对象.静态数据成员的初始化必 ...

初识JAVA07:自定义类、构造方法、this关键字、static关键字、block关键字、Debug调试工具