面向对象
this关键字的概述和应用
为什么要有this
当 局部变量 和 成员变量 的 名字相同 的时,如果我们不使用this关键字,那么会导致局部变量隐藏(冲突)了成员变量的问题。
this关键字特点
表示当前类的对象引用
简单记:它就代表当前类的一个对象。谁调用这个方法,该方法的内部的this就代表谁this的应用场景
解决局部变量隐藏(冲突)成员变量
示例代码
class Student {
private String name;
private int age;
private String sex;
public void setName(String name) {// String name = "张三疯";
// name = name;//因为有个原则叫就近原则,所以这个时候"张三疯"又赋值给局部变量了,没有赋值到我们希望的成员变量
this.name = name;// 谁调用这个方法,这个方法中的this就是谁
}
public String getName() {
return name;
}
public void show() {
System.out.println(this.name + " " + age + " " + sex);// 这里隐藏了this
}
}
// 测试类 ,玩基本类的.创建对象,通过对象调成员
class Demo {
public static void main(String[] args) {
// 创建对象
Student s = new Student();
// 赋值
s.setName("张三疯");
s.setAge(50);
s.setSex("男");
s.show();
}
}
构造方法
对已经做好封装的类(Person为例),由于Person中的属性都被 private 了,外界无法直
接访问属性,如果想设置属性值,就必需使用相应的set和get方法。当创建人对象时,一创建就要明确其姓名和年龄,那该怎么做呢?
- 什么是构造方法?
从字面上理解就是 创建对象 时要 执行 的方法。那么
只要在 new 对象时,知道其执行的构造方法是什么,就可以在执行这个方法的时候给对象进行 属性赋值 。
构造方法也叫构造器,主要作用是创建对象,给对象中的 成员 进行 初始化
- 构造方法格式
修饰符 构造方法名(参数列表){
}
- 构造方法的特点
构造方法 没有返回值类型 以及 返回值 (特殊的方法,连void都没有)。不需要写返回值。
因为它是为构建对象的,对象创建完,方法就执行结束。构造方法名称必须和 类名保持一致
示例代码
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student s = new Student("张三", 18);
System.out.println(s.getName());
System.out.println(s.getAge());
}
}
public class Student {
private String name;
private int age;
public Student(String name,int age){
this.name = name;
this.age = age;
System.out.println("执行了");
}
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;
}
}
默认构造
- 在没有学习构造方法之前,我们也可以通过new关键字创建对象,并调用相应的方法,同时在描述事物时也没有写构造方法。这是为什么呢?
在之前学习的过程中,描述事物时,并没有显式指定构造方法,当在编译Java文件时,编译器会自动给class文件中添加 默认的构造方法 。如果在描述类时,我们显式指定了构造方法,那么,当在编译Java源文件时,编译器就 `不会再给 class文件中添加 默认构造 方法。
代码格式
class Student {
//如果没有显式指定构造方法,编译会在编译时自动添加默认的构造方法
//public Student(){} //空参数的默认构造方法
}
当在描述事物时,要根据描述事物的特点来确定是否需要构造方法:
当描述的事物在 创建 其对象时就要 明确属性 的值,这时就需要在定义类的时候书写带参数的构造方法。
若创建对象时不需要明确具体的数据,这时可以不用书写构造方法(不书写也有默认的构造方法)。构造方法的细节:
一个类中可以有 多个构造方法 ,多个构造方法是以 重载 的形式存在的
构造方法是可以被 private 修饰的
作用:其他程序无法创建该类的对象。
示例代码
class Student {
private int age;
private String name;
// 私有无参数的构造方法,即外界不能通过new Person();语句创建本类对象
private Student() {
}
// 多个构造方法是以重载的形式存在
public Student(int age) {
this.age = age;
}
Person(String name, int age) {
this.name = name;
this.age = age;
}
}
构造方法和一般方法区别(了解)
到目前为止,学习两种方法,分别为 构造方法 和 普通方法 ,那么他们之间有什么异同呢?
- 构造方法在对象创建时就执行了,而且只执行一次。
- 一般方法是在对象创建后,需要使用时才被对象调用,并可以被多次调用。
有了构造方法之后可以对对象的属性进行初始化,那么还需要对应的set和get方法吗?
- 需要相应的set和get方法,因为对象在创建之后需要修改和访问相应的属性值时,在这 时只能通过set或者get方法来操作。
代码示例
class Demo {
public static void main(String[] args) {
// 使用无参构造
Student s = new Student();
System.out.println(s.getName());
System.out.println("---------使用带参构造方法------------------------");
// 使用带参构造方法
Student s2 = new Student("学员一");
System.out.println(s2.getName());
System.out.println("---------使用带两个参构造方法------------------------");
// 使用两个带参构造
Student s3 = new Student("学员二", 18);
System.out.println(s3.getName() + "---" + s3.getAge());
// s3 = new Student("学员三",19);
s3.setAge(19);
System.out.println(s3.getName() + "---" + s3.getAge());
// 我们之前通过set方法进行赋值,现在可以通过构造器进行赋值
}
}
class Student {
private String name;
private int age;
// 构造方法的重载
public Student() {
System.out.println("哈哈,我是无参构造");
// this.name = "学员一";
// 通过构造方法可以为成员变量赋值,也就是对成员变量进行了初始化
}
// 这是一个带一个参数的构造
public Student(String name) {
this.name = name;
}
// 这是带两个参数的构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 对外提供公共的
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;
}
}
构造方法的重载及注意事项
案例演示
构造方法的重载
构造方法注意事项
构造方法注意事项
如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
注意:这个时候,如果我们还想使用无参构造方法,就必须自己给出。建议永远自己给出无参构造方法
构造方法的运行特点,在new的时候运行一次 往后就不再运行
给成员变量赋值的两种方式
setXxx()方法
构造方法
static概念
当在定义类的时候,类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时,如果该方法没有访问到对象的 成员变量 时,为了调用方法而去创建这个对象有些多余。
可是不创建对象,方法又调用不了,这时就会想,那么我们能不能不创建对象,就可以调用方法呢?
可以的,我们可以通过static关键字来实现。static它是静态修饰符,一般用来修饰类中的成员。
- 班级里有多个学生,每个学生名字不一样,但是班级是一样的,每次创建一个对象都要给班级开辟空间,有点浪费内存空间,有没有一种好的方式: 让这几个对象共用这个班级?
可以使用static关键字
静态使用
- 多个对象共享一个数据
学生:Student。每个学生都有班级,比如:JF01。
针对某个成员是被所有对象共享的时候,该成员就可以被静态(static)修饰。
代码示例
class Student {
String name;
// String team;
static String team;// 使用静态,多个对象共享一个team数据
public void show() {
System.out.println(name + "-----" + team);
}
}
class Demo {
public static void main(String[] args) {
Student.team = "jf01";
Student s1 = new Student();
s1.name = "学生1";
// s1.team = "jf01";
s1.show();
Student s2 = new Student();
s2.name = "学生1";
// s2.team = "jf01";
s2.show();
// 学生的team属性相对来说是独立的
}
}
static关键字的特点
- 被static修饰的成员变量属于类,不属于这个类的某个对象。(也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量)
- static关键字的特点
随着类的加载而加载
优先于对象存在(直接类名调用)
被类的所有对象共享
举例:咱们班级的学生应该共用同一个班级编号。
—-某个成员是被所有对象共享的时候,该成员就可以被静态(static)修饰。举例:
饮水机(用静态修饰)
水杯(不能用静态修饰)
可以通过类名调用
—其实它本身也可以通过对象名调用。
—推荐使用类名调用。
案例演示: static关键字的特点
class Student {
int age = 20;
static int age2 = 25;
}
class StudentDemo {
public static void main(String[] args) {
// 创建一个学生对象
// Student s = new Student();
// System.out.println(s.age);
// System.out.println(Student.age);//无法从静态上下文中引用非静态 变量 age
// System.out.println(s.age2);
System.out.println(Student.age2);
}
}
静态变量和非静态成员变量的区别
按照是否静态的对类成员变量进行分类,可分两种
静态变量
实例变量(成员变量)静态修饰成员变量和局部变量区别:
静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类的过程中完成静态变量的内存分配(优先于对象存在),可用类名直接访问(方便),当然也可以通过对象来访问(但是这是不推荐的)。
实例变量,每创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响(灵活)。所以一般在需要实现以下两个功能时使用静态变量:
在对象之间共享值时
方便访问变量时
static修饰成员方法
static 修饰的方法我们称之为静态方法,通过类名对其进行直接调用。由于他在类加载的时候就存在了,它不依赖于任何实例。
使用场景:
因为静态不依赖对象存在,所以一般会用做工具类(直接类名调用)
如 Math 类的所有方法都是静态 static 的(工具类)。
示例代码
public class StaticDemo {
public static void iStatic() {
System.out.println("我是静态的方法,可以通过类名和对象进行调用。");
}
public void noStatic() {
System.out.println("我不是静态方法,只能通过对象调用。");
}
}
// 静态调用过程
public class Demo {
public static void main(String[] args) {
StaticDemo.iStatic();// 静态方法
StaticDemo sd = new StaticDemo();
sd.noStatic();// 非静态
}
}
static的注意事项
- static的注意事项
在静态方法中是没有this关键字的
如何理解呢?
—-静态是随着类的加载而加载,this是随着对象的创建而存在。
—-静态比对象先存在。
静态方法只能访问静态的成员变量和静态的成员方法
—-静态只能访问静态,非静态可以访问静态的也可以访问非静态的
案例演示: static的注意事项
public class Demo {
int a = 10;// 非静态
static int b = 10;// 静态
public static void main(String[] args) {
iStatic();
System.out.println(b);
System.out.println(a);// 错误【无法从静态上下文中引用非静态 方法 noStatic()】
noStatic();// 错误【无法从静态上下文中引用非静态 方法 noStatic()】
}
public static void iStatic() {
System.out.println("我是静态的方法");
}
public void noStatic() {
System.out.println("我不是静态方法");
}
}
static关键字的特点总结
- 静态可以修饰成员变量、方法、代码块
- 随着类的加载而加载
- 优先于对象存在(直接类名调用)
- 静态修饰的属性,被类的所有对象共享
- 静态修饰的方法,可以类名直接调用
代码块
- 静态代码块、构造代码块、构造函数执行顺序(了解)
- 静态代码块,它是随着类的加载而被执行,只要类被加载了就会执行,而且只会加载一 次,主要用于给类进行初始化。
- 构造代码块,每创建一个对象时就会执行一次,且优先于构造函数,主要用于初始化不同 对象共性的初始化内容和初始化实例环境。
- 构造函数,每创建一个对象时就会执行一次。同时构造函数是给特定对象进行初始化,而 构造代码是给所有对象进行初始化,作用区域不同。