文章目录
1 面向对象
我们都知道C语言是面向过程的,C++,Java等语言是面向对象的,那么这两者之间有什么区别呢?来举一个洗衣服的例子:
面向过程:把衣服放在盆中->加入洗衣液->加水->揉洗->换水漂洗->洗好了
面向对象:把衣服和洗衣液放入洗衣机中->洗好了
我们可以看出来,面向过程注重的是过程,而面向对象注重的是对象,也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来,衣服、洗衣液、洗衣机都可以称为是对象。
2 类与对象
类就是一类对象的统称。
对象就是这一类具体化的一个实例。
所以我们经常会听到一句话:类实例化后就得到了对象,即类是抽象的,对象是具体的。一个类可以生成无数个对象,如果这么说还是有点抽象的话,那我们来举个例子:现在有鞋这么一个类,由这个类我们可以实例化出很多对象,如:运动鞋、休闲鞋、皮鞋等等。
3 类的成员
类的成员有:字段(成员变量)、方法、代码块、内部类和接口等等。
初识面向对象,这里只介绍前面三个。
3.1 字段
字段又可以称为属性、成员变量。我们来看代码:
public class Test {
public String name = "ccc";
public int age;
public static void main(String[] args) {
Test test = new Test();
test.name = "abc";
test.age = 20;
System.out.println(test.name);
System.out.println(test.age);
}
}
输出如下:
abc
20
在Test类下的name、age就被称为属性或成员变量,我们可以在创建的时候给其赋值,也可以在main方法中赋值或修改其值,但是在调用成员变量的时候需要用对象去调用,即用new出来的test对象才能对其进行调用。
注意事项:
- 在成员变量没有赋值之前,会有一个默认值.
- 对于各种数字类型,其默认值为0.
- 对于boolean类型,其默认值为false.
- 对于String等引用类型,默认值为null.
对于null而言:
null在Java中为”空引用“,意思是不指向任何对象,如果对其进行操作,就会出现异常(空指针异常)。
3.2 方法
方法用于描述一个对象的行为,我们来看下面代码:
public class Test {
public String name = "张三";
public int age = 18;
public void show(){
System.out.println("我叫" + name + ",我今年" + age + "岁");
}
public static void main(String[] args) {
Test test = new Test();
test.show();
}
}
输入为:
我叫张三,我今年18岁
其中的show,我们就称为方法,想要调用方法,还是需要创建对象,方法可以满足某种行为,我们还可以根据具体的需要去设置方法的返回类型,传入的参数等等。
3.3 static关键字
- 修饰成员变量
- 修饰方法
- 修饰代码块
- 修饰类
3.3.1 修饰成员变量
被static修饰的成员变量称为静态成员变量,存放在方法区,又叫静态区,而普通的成员变量是存放在堆区的,局部变量存放在栈区。我们来看看普通的成员变量和静态成员变量有什么区别:
public class Test {
public int a;
public static int b;
public static void main(String[] args) {
Test test1 = new Test();
test1.a++;
test1.b++;
System.out.println(test1.a);
System.out.println(test1.b);
System.out.println("-------------------");
Test test2 = new Test();
test2.a++;
test2.b++;
System.out.println(test2.a);
System.out.println(test2.b);
}
}
输出如下:
1
1
-------------------
1
2
究其原因,普通成员变量是存放在堆区的,在每new一个新的对象时,都会给该对象在堆区开辟一片新的空间用来存放成员变量a,然后未初始化的成员变量值是0,所以test1和test2在调用之前,a的值都为0,调用后都为1,刚刚我们说过static修饰的成员变量是存放在方法区的,静态成员变量是属于类的,我们调用它的时候完全可以不用new对象,并且它在方法区中只有一份,每次调用的都是唯一的那一份,所以后面test2调用b的时候,b的值会变成2。
3.3.2 修饰方法
同上,被static修饰的方法我们就称为静态方法。
- 静态方法属于类,不属于类的对象
- 可以直接调用静态方法,不需要创建对象
- 静态方法可以访问静态数据成员,并可以更改静态数据成员的值
来看代码:
public class Test {
public int a;
public static int b;
public static void change(){
b = 100;
//a = 10; 报错,不可以访问非静态成员变量
}
public static void main(String[] args) {
Test.change();
System.out.println(b);
}
}
输出为:
100
我们可以看出static修饰的方法和普通方法的区别,至于如何去使用,就需要结合具体的情况。
static修饰代码块和类在此处先不作陈述。
4 封装
4.1 private封装
private/ public 这两个关键字表示 “访问权限控制”。我们来看看这两者的区别:
直接使用public
class Person {
public String name = "张三";
public int age = 18;
}
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
}
}
输入为:
我叫张三, 今年18岁
使用private
class Person {
private String name = "张三";
private int age = 18;
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "岁");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
输入为:
我叫张三, 今年18岁
对于成员变量,其实我们根本不需要知道,也不需要关注一个类都有哪些 private 的成员。从而让类调用者以更低的成本来使用类。并且使用public修饰成员变量其维护成本也会更高,用private进行封装后其可行性更佳。
4.2 getter和setter方法
当我们使用 private 来修饰成员变量的时候, 就无法直接使用这个成员变量了。而我们想要使用它,无非就是想给它赋值或得到其值,在Java中为了解决这个问题,引入了getter和setter方法。
public class Test {
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
public static void main(String[] args) {
Test test = new Test();
test.setName("张三");
System.out.println(test.getName());
test.setAge(18);
System.out.println(test.getAge());
}
}
输入为:
张三
18
其中的getName和getAge即为getter方法,表示获取这个成员的值,setName和setAge即为setter方法,表示设置这个成员的值。
注意事项:
- 当set方法的形参名字和类中的成员属性的名字一样的时候,如果不使用this, 相当于自赋值. this表示当前实例的引用。
- 不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法。
5 构造方法
5.1 基本语法
构造方法是一种特殊方法,在new一个对象的时候会自动调用,用于完成初始化操作。
new执行过程
- 为对象分配内存空间
- 调用对象的构造方法
规则
- 方法名必须与类名相同
- 构造方法没有返回值类型
- 每个类中至少有一个构造方法(如果不定义的话系统会自动生成一个无参构造)
- 若定义了构造方法,则默认的无参构造就没有了
- 构造方法支持重载,和普通方法的重载一样
public class Test {
private String name;
private int age;
public Test(){
System.out.println("这是无参构造");
}
public Test(String name){
this.name = name;
}
public Test(String name,int age){
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Test test = new Test();
Test test1 = new Test("张三");
System.out.println(test1.name);
System.out.println(test1.age);
Test test2 = new Test("张三", 18);
System.out.println(test2.name);
System.out.println(test2.age);
}
}
输出为:
这是无参构造
张三
0
张三
18
从输出可以看出,在new对象时,会根据传入参数的个数自动找到对应的构造方法。
5.2 this关键字
this表示当前对象引用,而不是当前对象,可以借助this来访问对象的成员变量和方法。
public class Test {
private String name;
private int age;
public Test(){
this("张三",18); //this调用构造方法
}
public Test(String name,int age){
this.name = name;
this.age = age;
}
public void show(){
System.out.println("我叫" + name + ",今年" + age + "岁");
}
public static void main(String[] args) {
Test test = new Test();
test.show();
}
}
输入为:
我叫张三,今年18岁
6 代码块
代码块可以分为四种:
- 普通代码块
- 构造代码块
- 静态代码块
- 同步代码块
6.1 普通代码块
定义在方法中的代码块就称为普通代码块。
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义,普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
这种用法无较大意义。
6.2 构造代码块
定义在类中的代码块就称为构造代码块,一般用于初始化成员变量。
public class Test {
private String name;
private int age;
//构造代码块
{
this.name = "张三";
this.age = 18;
System.out.println("构造代码块");
}
public void show(){
System.out.println("我叫" + name + ",今年" + age + "岁");
}
public static void main(String[] args) {
Test test = new Test();
test.show();
}
}
输出为:
构造代码块
我叫张三,今年18岁
6.3 静态代码块
也是在类中定义,一般用于初始化静态成员变量。和构造代码块用法类似,要在{}前面加上static关键字修饰。
注意事项:
- 静态代码块不管生成多少个对象,其只会执行一次,且是最先执行的。
- 静态代码块执行完毕后, 实例代码块(构造块)执行,再然后是构造函数执行。