目录
一、面向过程和面向对象
本文是用来记录自己的学习过程
1.1 面向过程
当需要实现一个功能的时候,每一个具体的步骤都需要亲力亲为,详细处理每一个细节。
1.2 面向对象
当需要实现一个功能的时候,不关心具体的步骤,而是找一个已经具有该功能的类,来调用类中的方法。
小例子:创建一个数组[10,20,30,40,50],要求打印格式为[10,20,30,40,50]
public class Demo1 {
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.println(Arrays.toString(array));
}
}
面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者,面向对象的语言中,包含了三大基本特征,即封装、继承和多态。Java是一种面向对象的语言。
二、Java中的类
2.1 类的定义
类:是一组相关属性和行为的集合。可以看成是一类事务的模板,使用事务的属性特征和行为特征来描述该类事务,是抽象的。
属性:该事务的状态信息(一组成员变量)
行为:该事务能够做的事情,即类中的函数或者方法()
2.2 对象
对象:是一类事务的具体体现。对象是类的实例(不是女朋友),所以具备该类事务的属性和行为。类是抽象的,对象是具体的。
2.3 类定义的格式
public class ClassName{
// 成员变量
// 成员方法
}
- 定义类:就是定义类的成员,包括成员变量和成员方法
- 成员变量:和以前定义变量几乎是一样的。只不过位置发生了改变。在类中,方法外。
- 成员方法:和以前定义方法几乎是一样的。只不过把static去掉,static的作用在面向对象
- 注意事项:
成员变量是直接定义在类当中的,在方法外边。成员方法不要写在static关键字。
2.3.1类的定义格式举例
/*
成员变量(属性):
String name; //姓名
int age; // 年龄
成员方法(行为):
public void eat(); // 吃饭
public void sleep(); // 睡觉
public void study(); // 学习
*/
public class Student {
String name;
int age;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void study(){
System.out.println("学习");
}
}
2.3.2 类的调用
Student类接上文,文件结构如下图所示
通常情况下,一个类并不能直接使用,需要根据类创建一个对象,才能使用。
- 导包:也就是指出需要使用的类,在什么位置。
import 包名称.类名称;
import com.Day6Demo.Student
对于和当前类属于同一个包的情况下,可以省略导包语句不写。 - 创建格式:
类名称 对象名 = new 类名称();
Student stu = new Student() - 使用,分为两种情况:
使用成员变量:对象名.成员变量名
使用成员方法:对象名.成员方法名(参数)
新建一个java类(StudentClass02)调用Student类,代码如下:
public class StudentClass02 {
public static void main(String[] args) {
// 1. 导包
// 对于和当前类属于同一个包的情况下,可以省略导包语句不写。
// 2. 创建格式:
// 类名称 对象名 = new 类名称();
Student stu = new Student();
// 3. 使用
// 使用成员变量:对象名.成员变量名
System.out.println(stu.name);
System.out.println(stu.age);
System.out.println("=================");
//使用成员方法:对象名.成员方法名(参数)
stu.eat();
stu.sleep();
stu.study();
System.out.println("=================");
//给成员变量重新赋值
stu.name = "周杰伦";
stu.age = 18;
System.out.println(stu.name);
System.out.println(stu.age);
}
}
三、Java类中关键字
3.1 private
面向对象有三大特征:封装、继承和多态。
- 封装:就是将类中一些细节信息隐藏下来,对于外界不可见,只对外公开接口。
- 继承:继承是面向对象的基本特征之一,继承机制允许创建分等级层次的类。继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
- 多态:同一个行为具有多个不同表现形式或形态的能力。是指一个类实例(对象)的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着,虽然针对不同对象的具体操作不同,但通过一个公共的类,它们(那些操作)可以通过相同的方式予以调用。
封装性在Java当中的体现:
- 方法就是一种封装
- 关键字private也是一种封装(私有化,类似于)
以Student类为例,想要对Student的成员变量进行保护,需要使用private方法,另外,经过封装后的类成员变量不能直接使用,需要定义Setter和Getter方法(必须叫setXxx或者getXxx命名规则)。代码如下:
public class Person {
String name;
private int age;
public void show() {
System.out.println("姓名:" + name + "年龄:" + age);
}
// 这个成员方法,专门用于向age设置数据
public void setAge(int num){
if (num < 150 && num>0){
age = num;
}else {
System.out.println("格式输入不对!");
}
}
// 这个成员方法,专门用于获取age的数据
public int getAge() {
return age;
}
}
使用private封装后,想要修改或者调用Student的成员变量,需要使用方法为:
public class Demo1Student {
public static void main(String[] args) {
Student student = new Student();
student.setName("张三");
student.setAge(12);
student.setMale(true);
System.out.println("姓名:"+student.getName());
System.out.println("年龄:"+student.getAge());
}
}
3.2 this
当方法的局部变量和类的成员变量重名的时候,根据“就近原则”,优先使用局部变量。如果我们就需要这个局部变量名称,我就不改名,这个时候,需要对成员变量修改格式:this.成员变量this就相当于这个类,比如说我在Student类中使用this,那么this就是Student,this.成员变量就等于Student.成员变量(通过谁调用的方法,谁就是this,有点类似于python中的self)
3.3 static
详细用法请移步Java中static关键字的解析
3.4 final
final 关键字代表最终的、不可改变的。一旦使用final修饰,那么被修饰的就不能在进行任何改变。“一次赋值,终生不变”
常见的四种用法:
1. 可以用来修饰一个类;
当final关键字用来修饰一个类的时候,格式:
public final class 类名称{
// ...
}
含义:当前的这个类不能有任何的子类(太监类)
注意:一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写(因为没儿子)
2. 可以用来修饰一个方法;
当final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写。
格式:
修饰符 final 返回值类型 方法名称(参数列表){
// 方法体
}
注意事项:对于类、方法来说,abstract关键字和final关键字不能同时使用,因为互相矛盾。
3. 还可以用来修饰一个局部变量;
// 对于基本类型来说,不可变说的是变量当中的数据不能改变
// 对于引用类型来说,不可变说的是变量当中的地址值不能改变
final Student stu3 = new Student ("王五");
// 错误写法!final的引用变量类型,其中的地址不可改变
//stu3 = new Student ("王祖贤");
System.out.println (stu3.getName ());//王祖贤
stu3.setName ("袁咏仪");
System.out.println (stu3.getName ());//袁咏仪
4. 还可以用来修饰一个成员变量。
对于成员变量来说,如果使用final关键字修饰,那么这个变量也照样不能修改。
1. 由于成员变量具有默认值,所以用了final之后必须手动赋值,不会再给默认值了。
2. 对于final修饰的成员变量,要么直接赋值,要么通过构造方法赋值,二者选其一。
3. 必须保证类当中所有重载的构造方法,都最终会对final的成员变量进行赋值。
四、构造方法
4.1 定义
1. 构造方法是专门用来创建对象的方法,当我们通过关键字new来创建对象时,
其实就是再调用构造方法。(类似python中的__init__)
2. 格式:
public 类名称(参数类型 参数名称){
方法体
}
3. 注意事项:
- 构造方法的名称必须和所在的类名称完全一样
- 构造方法不要写返回值类型,连void都不写
- 构造方法不能return一个具体的返回值
- 如果没有写构造方法,那么编译器会默认给我们生成一个构造方法,没有参数、方法体什么事情都不做。一旦写了至少一个构造方法,那么编译器就不会在默认生成构造方法
- 构造方法也可以进行重载(方法名称相同,参数不同)。
public class Student {
String name;
int age;
public Student() {
System.out.println("无参数构造方法!");
}
public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println("全参数构造方法!");
}
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 class Demo1Student {
public static void main(String[] args) {
Student student1 = new Student();
Student student2 = new Student("张三", 20);
System.out.println("姓名" + student1.getName() + "," + "年龄" + student1.getAge());
System.out.println("=================================");
System.out.println("姓名" + student2.getName() + "," + "年龄" + student2.getAge());
System.out.println("=================================");
student1.setName("王老六");
student1.setAge(98);
System.out.println("姓名" + student1.getName() + "," + "年龄" + student1.getAge());
System.out.println("=================================");
student2.setName("周杰伦");
student2.setAge(40);
System.out.println("姓名" + student2.getName() + "," + "年龄" + student2.getAge());
}
}
五、Java标准类和隐匿对象
5.1 定义一个标准类
一个标准的类通常要拥有下面四个组成部分:
1、所有的成员变量都要使用private关键字修饰
2、为每一个成员变量编写一对Getter/Setter方法
3、编写一个无参数的构造方法
4、编写一个全参数的构造方法
这样标准的类也叫做Java Bean(Java豆)
代码为:
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
5.2 隐匿对象
创建对象的标准格式:
类名称 对象名 = new 类名称();
匿名对象就是只有右边的对象,没有左边的名字和赋值运算符。
new 类名称()
注意事项:匿名对象只能使用唯一一次,下次再用不得不再创建一个新对象。
使用建议:如果确定有一个对象只需要使用一次,就可以使用匿名对象,因为Java是面向对象的,所以使用隐匿对象,可以节省不必要的内存空间。
代码:
import java.util.Scanner;
public class Demo2Anonymous {
public static void main(String[] args) {
// 普通使用方式
//Scanner sc = new Scanner(System.in);
//int num = sc.nextInt();
//System.out.println("输入的数字是:"+num);
//匿名对象的方式
//int num = new Scanner(System.in).nextInt();
//System.out.println("输入的数字是:" + num);
//使用一般方法写入参数
//Scanner sc = new Scanner(System.in);
//methodParam(sc);
// 使用匿名对象来进行传参
//methodParam(new Scanner(System.in));
Scanner sc = methodReturn();
int num = sc.nextInt();
System.out.println("输入的数字是:" + num);
}
public static void methodParam(Scanner sc){
int num = sc.nextInt();
System.out.println("输入的数字是:" + num);
}
public static Scanner methodReturn(){
return new Scanner(System.in);
}
}
六、Java中面向对象的三大特征
七、Java中的内部类