构造方法
语法:
//类名 对象名 = new 构造方法();
//例如
Student student = new Student()(
作用:
是一种特殊的方法,是一个与类同名的方法，每个类的实例创建都是通过构造方法来完成的，主要的作用是为 了属性的初始化
特点:
- 构造方法的方法名必须和类名相同
- 构造方法没有返回值，甚至viod也没有
- 每个类中一定会存在一个无参构造方法，类生成时存在
- 可以进行类和类之间的值传递 ，属性的初始化
- .构造方法在初始化对象时自动执行,一般不能显式地直接调用.当同一个类存在多个构造方法时，java编译系统会自动按照初始化时最后面括号的参数个数以及参数类型来自动一一对应。完成构造方法的调用。
- 构造方法分为两种：无参构造方法 有参构造方法
- 构造方法可以被重载。没有参数的构造方法称为默认构造方法，与一般的方法一样，构造方法可以进行任何活动，但是经常将他设计为进行各种初始化活动，比如初始化对象的属性。
this关键字
语法:
// this.属性
// this.成员方法
// this()构造方法
//this.属性实例
public class Student {
public String name; //学生姓名
public int age; //学生年龄
public String sex; //性别
public Student() {
//this.属性
this.name = "Epiphany";
this.age = 18;
this.sex = "男";
}
}
//this.成员方法
public class Student {
public String name; //学生姓名
public int age; //学生年龄
public String sex; //性别
public Student() {
//this.属性
this.name = "Epiphany";
this.age = 18;
this.sex = "男";
//this.成员方法
this.print();
}
public void print() {
System.out.println("我叫"+this.name+",今年"+this.age+"岁");
}
}
//this.()构造方法
public class Student {
public String name; //学生姓名
public int age; //学生年龄
public String sex; //性别
public Student() {
//this.属性
this.name = "Epiphany";
this.age = 18;
this.sex = "男";
//this.成员方法
this.print();
}
public Student(String name) {
this.name = name;
}
public Student(String name,int age,String sex) {
//this() 构造方法
this(name)
this.age = age;
this.sex = sex;
}
public void print() {
System.out.println("我叫"+this.name+",今年"+this.age+"岁");
}
}
含义:
对类的当前实例的引用，只能在类的上下文使用
作用:
a. 使用this关键字调用成员变量(属性)，解决成员变量和局部变量的同名冲突
public Student(String name) {
this.name = name; // 成员变量和局部变量同名时必须使用this关键字
}
b. 使用this关键字调用成员方法
public Student(String name) {
this.name = name;
this.print();
}
public void print() {
System.out.println("我叫"+this.name+",今年"+this.age+"岁");
}
c. 使用this关键字调用已经定义好的构造方法
以下代码定义了 Employee 类 并定义了两个有参构造方法
public class Employee {
/** * 员工姓名 */
public String name;
/** * 年龄 */
public int age;
/**所在的部门*/
public String department;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public Employee(String name, int age, String department) {
this.name = name;
this.age = age;
this.department = department;
}
}
观察上面的代码可以发现,在两个带参构造方法中存在如下代码:
this.name = name;
this.age = age;
在这种情况，我们有没有一种方法来减少代码量呢?
有!
那就是使用this关键字调用另外一个包含这两行代码的带参构造方法
public class Employee {
/** * 员工姓名 */
public String name;
/** * 年龄 */
public int age;
/**所在的部门*/
public String department;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public Employee(String name, int age, String department) {
this(name,age); //调用已经定义好的构造方法
this.department = department;
}
}
重载
例子:
//参数列表的类型不同，方法名不同
System.out.println("good");//参数是String类型
System.out.println(true);//参数是boolean类型
System.out.println(100);//参数是int类型
//还有其他例子 比如 String 类中的indexof()方法、类中的构造方法
**含义: **
Java 允许同一个类中有同名的方法 但是参数列表不相同即可 这种情况就叫 方法重载(overLoad)
特点:
方法重载的依据如下:
- 必须要在同一个类中
- 方法名必须相同
- 参数列表(方法参数的个数或者参数类型)不能相同
需要注意的是方法的返回值和方法的访问修饰符 不能作为判断方法之间是否构成方法重载的依据
优点及使用:
以下面的示例来举例如何使用方法重载:
public class Adder {
public static void main(String[] args) {
Adder adder = new Adder();
int a = 6, b = 8;
System.out.println(a + "+" + b + "=" + adder.getSum(a, b));
double c = 9.1, d = 10.3;
System.out.println(c + "+" + d + "=" + adder.getSum(c, d));
String s1 = "Hello", s2 = "World";
System.out.println(s1 + "+" + s2 + "=" + adder.getSum(s1, s2));
}
//方法重载
public int getSum(int a, int b) {
return a + b;
}
public double getSum(double a, double b) {
return a * b;
}
public String getSum(String s1, String s2) {
return s1 + s2;
}
}
输出结果如下:
优点:
** 使用方法重载其实就是避免出现繁多的方法名，有些方法的功能是相似的，如果重新建立一个方法，重新取个方法名称，会降低程序可读性。**
封装
** 属性私有，带上get/set**
请看下面这一段代码:
Student student = new Student();
student.age = 999;
很明显，创建对象肯定是不会有语法上的错误的,但是这不符合实际情况,，因为学生年龄不可能是999岁的 那如何限制随意赋值引起的不合理情况呢? 这个时候就需要Java中的封装来实现了
封装的概念:
封装是面向对象的三大特性之一
将类的信息隐藏在类的内部，不允许外部程序直接访问从而破坏信息的完整
通过该类提供的方法实现对隐藏信息的操作和访问
封装的实现步骤:
第一步: 修改属性的可进行来限制对属性的访问
第二步：为每个属性创建一对 赋值(set) 和 取值(get) 方法，用来对这些属性的存取
第三步：在赋值方法(set) 中，可以加入对属性的存取控制语句来限制数据的不符合性
提示:在idea中快速生成get/set方法的快捷键 Alt + ins 选中 Getter and Setter
按照封装步骤来使用:
/**
* Created with IntelliJ IDEA.@author: TaoG
* Date: 2022/3/16
* Time: 10:42
* Describe: 房间类
*/
public class Room {
private String roowId;
private String roowName;
private int roowPrice;
public String getRoowId() {
return roowId;
}
public void setRoowId(String roowId) {
this.roowId = roowId;
}
public String getRoowName() {
return roowName;
}
public void setRoowName(String roowName) {
this.roowName = roowName;
}
public int getRoowPrice() {
return roowPrice;
}
public void setRoowPrice(int roowPrice) {
if (roowPrice <= 0 || roowPrice > 88) {
System.out.println("您选择的房间号有误");
roowPrice = 80;
}
this.roowPrice = roowPrice;
}
封装的好处:
隐藏类的细节,更加方便的来保护数据信息
static关键字
作用:
作修饰类的属性、方法和代码块。
使用 static 修饰的属性和方法不再属于具体的对象了，而是属于它所在的类
static修饰成员变量时：static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.
静态成员变量的访问方式：
方式一： 使用对象进行访问。
对象.属性名
方式二：可以使用类名进行访问。
类名.属性名
注意：
- 非静态成员变量不能类名直接访问，只能使用对象进行访问。
- 千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据 时才使用static修饰。
static修饰方法（静态的成员方法）:
访问方式：
方式一：可以使用对象进行访问。
对象.静态的函数名();
方式二：可以使用类名进行访问。
类名.静态函数名字。
推荐使用是类名直接访问静态的成员。
静态的成员变量与非静态的成员变量的区别：
- 作用上的区别：
- 静态的成员变量的作用共享一个 数据给所有的对象使用。
- 非 静态的成员变量的作用是描述一类事物的公共属性。
- 数量与存储位置上的区别：
- 静态成员变量是存储方法 区内存中，而且只会存在一份数据。
- 非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。
- 生命周期的区别：
- 静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。
2.非静态的成员数据是随着对象的创建而存在，随着 对象被垃圾回收器回收而消失。
静态方法要注意的事项：
- 静态方法是可以调用类名或者对象进行调用的，而非静态方法只能使用对象进行调用。
- 静态的方法可以直接访问静态的成员，但是不能直接访问非静态的成员。
原因：静态方法是可以使用类名直接调用的，这时候可能还没有存在对象，
而非静态的 成员数据是随着对象 的存在而存在的。 - 非静态的方法是可以直接访问静态与非静态的成员。
原因：非静态方法只能由对象调用，当对象存在的时候，静态数据老早就已经存在了，而非静态
数据也随着对象的创建而存在了。 - 静态方法不能出现this或者super关键字。
原因：因为静态的方法是可以使用类名调用的，一旦使用类名调用这时候不存在对象，而this
关键字是代表了一个方法 的调用者对象，这时候产生了冲突。
静态的数据的生命周期：静态的成员变量数据是优先于对象存在的。
static什么时候修饰一个方法？
如果一个方法没有直接访问到非静态的成员时，那么就可以使用static修饰了。 一般用于工具类型的方法
静态方法不能访问非静态的成员？
静态方法只要存在有对象，那么也可以访问非 静态的数据。只是不能直接访问而已。
扫一扫
2847
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
