0
点赞
收藏
分享

微信扫一扫

面向对象(二)-搞定她-搞定程序


​​面向对象(一)-搞定她-搞定程序​​

封装(private)

封装概述:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。

封装的好处


  • 隐藏实现细节,提供公共的访问方式
  • 提高了代码的复用性
  • 提高安全性。

封装原则


  • 将不需要对外提供的内容都隐藏起来。
  • 把属性隐藏,提供公共方法对其访问。

private关键字


  • 是一个权限修饰符。
  • 可以修饰成员(成员变量和成员方法)
  • 被private修饰的成员只在本类中才能访问。

private最常见的应用


  • 把成员变量用private修饰
  • 提供对应的getXxx()和setXxx()方法

一个标准的案例的使用

/**
封装和private的应用:
A:把成员变量用private修饰
B:提高对应的getXxx()和setXxx()方法
*/
//定义学生类
class Student {
//姓名
private String name;
//年龄
private int age;

//姓名获取值
public String getName() {
return name;
}

//姓名设置值
public void setName(String n) {
name = n;
}

//年龄获取值
public int getAge() {
return age;
}

//年龄赋值
public void setAge(int a) {
age = a;
}
}

//测试类
class StudentTest {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();

//使用成员变量
//错误:被私有修饰了,外界不能直接访问了
//System.out.println(s.name+"---"+s.age);
System.out.println(s.getName()+"---"+s.getAge());

//给成员变量赋值
//s.name = "林青霞";
//s.age = 27;
//通过方法给赋值
s.setName("林青霞");
s.setAge(27);
System.out.println(s.getName()+"---"+s.getAge());
}
}

运行结果:


面向对象(二)-搞定她-搞定程序_多态

private关键字

this关键字

this代表其所在函数所属对象的引用。换言之,this代本类对象的引用。

当成员变量和局部变量重名,可以用关键字this来区分,this就是所在函数所属对象的引用。

简单说,哪个对象调用了this所在的函数,this就代表哪个对象。一般方法调用默认加this。(方法被哪个对象调用,this就代表那个对象)

什么时候使用this呢?


  • 局部变量隐藏成员变量
  • 其他用法后面和super一起讲解

/**
我们曾经曰:起名字要做到见名知意。

this:是当前类的对象引用。简单的记,它就代表当前类的一个对象。

注意:谁调用这个方法,在该方法内部的this就代表谁。

this的场景:
解决局部变量隐藏成员变量

this:哪个对象调用那个方法,this就代表那个对象
*/
class Student {
private String name;
private int age;

public String getName() {
return name; //这里其实是隐含了this
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

class StudentTest2 {
public static void main(String[] args) {
//创建一个对象
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());

//创建第二个对象
Student s2 = new Student();
s2.setName("刘意");
s2.setAge(30);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}

运行结果:

面向对象(二)-搞定她-搞定程序_编程语言_02

this关键字

this关键字的内存图解:

面向对象(二)-搞定她-搞定程序_封装_03

this关键字

构造方法

构造方法作用概述:给对象的数据进行初始化

构造方法格式


  • 方法名与类名相同
  • 没有返回值类型,连void都没有
  • 没有具体的返回值

构造方法注意事项


  • 如果你不提供构造方法,系统会给出默认构造方法
  • 如果你提供了构造方法,系统将不再提供
  • 构造方法也是可以重载的

给成员变量赋值有两种方式


  • setXxx()
  • 构造方法

PS:

  1. 一般函数和构造函数什么区别呢?

构造函数:对象创建时,就会调用与之对应的构造函数,对对象进行初始化。

一般函数:对象创建后,需要函数功能时才调用。

构造函数:对象创建时,会调用并且只调用一次。

一般函数:对象创建后,可以被调用多次。

  1. 创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数,那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数,那么类中的默认构造函数就没有了。

  1. 多个构造函数是以重载的形式存在的。
/**
我们一直在使用构造方法,但是,我们确没有定义构造方法,用的是哪里来的呢?

构造方法的注意事项:
A:如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
B:如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
注意:这个时候,如果我们还想使用无参构造方法,就必须自己给出。建议永远自己给出无参构造方法

给成员变量赋值有两种方式:
A:setXxx()
B:构造方法
*/

class Student {
private String name;
private int age;

public Student() {
//System.out.println("我给了,你还给不");
System.out.println("这是无参构造方法");
}

//构造方法的重载格式
public Student(String name) {
System.out.println("这是带一个String类型的构造方法");
this.name = name;
}

public Student(int age) {
System.out.println("这是带一个int类型的构造方法");
this.age = age;
}

public Student(String name,int age) {
System.out.println("这是一个带多个参数的构造方法");
this.name = name;
this.age = age;
}

public void show() {
System.out.println(name+"---"+age);
}
}

class ConstructDemo2 {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
System.out.println("-------------");

//创建对象2
Student s2 = new Student("林青霞");
s2.show();
System.out.println("-------------");

//创建对象3
Student s3 = new Student(27);
s3.show();
System.out.println("-------------");

//创建对象4
Student s4 = new Student("林青霞",27);
s4.show();
}
}

构造方法和成员变量初始化顺序

执行父类静态代码 执行子类静态代码

初始化父类成员变量(我们常说的赋值语句)

初始化父类构造函数

初始化子类成员变量

初始化子类构造函数

类的成员方法

成员方法其实就是我们前面讲过的方法

方法具体划分:


  • 根据返回值:有明确返回值方法;返回void类型的方法
  • 根据形式参数:无参方法;带参方法

一个基本类的标准代码写法

/**
一个标准代码的最终版。

学生类:
成员变量:
name,age
构造方法:
无参,带两个参
成员方法:
getXxx()/setXxx()
show():输出该类的所有成员变量值

给成员变量赋值:
A:setXxx()方法
B:构造方法

输出成员变量值的方式:
A:通过getXxx()分别获取然后拼接
B:通过调用show()方法搞定
*/
class Student {
//姓名
private String name;
//年龄
private int age;

//构造方法
public Student() {
}

public Student(String name,int age) {
this.name = name;
this.age = age;
}

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;
}

//输出所有的成员变量值
public void show() {
System.out.println(name+"---"+age);
}
}

//测试类
class StudentTest {
public static void main(String[] args) {
//方式1给成员变量赋值
//无参构造+setXxx()
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
//输出值
System.out.println(s1.getName()+"---"+s1.getAge());
s1.show();
System.out.println("----------------------------");

//方式2给成员变量赋值
Student s2 = new Student("刘意",30);
System.out.println(s2.getName()+"---"+s2.getAge());
s2.show();
}
}

运行结果:

面向对象(二)-搞定她-搞定程序_多态_04

类的成员方法

2.11 类的初始化过程

Student s = new Student();在内存中做了哪些事情?


  • 加载Student.class文件进内存
  • 在栈内存为s开辟空间
  • 在堆内存为学生对象开辟空间
  • 对学生对象的成员变量进行默认初始化
  • 对学生对象的成员变量进行显示初始化
  • 通过构造方法对学生对象的成员变量赋值
  • 学生对象初始化完毕,把对象地址赋值给s变量

面向对象(二)-搞定她-搞定程序_编程语言_05

类的初始化过程

static关键字

static关键字可以修饰成员变量和成员方法

static关键字特点


  • 随着类的加载而加载
  • 优先于对象存在
  • 被类的所有对象共享
  • 这也是我们判断是否使用静态关键字的条件
  • 可以通过类名调用

static关键字注意事项


  • 在静态方法中是没有this关键字的
  • 静态方法只能访问静态的成员变量和静态的成员方法

静态的内存图

面向对象(二)-搞定她-搞定程序_类_06

静态的内存图

静态变量和成员变量的区别

面向对象(二)-搞定她-搞定程序_编程语言_07

静态变量和成员变量的区别

main方法是静态的

public static void main(String[] args) {}


  • public 被jvm调用,访问权限足够大。
  • static 被jvm调用,不用创建对象,直接类名访问
  • void被jvm调用,不需要给jvm返回值
  • main 一个通用的名称,虽然不是关键字,但是被jvm识别
  • String[] args 以前用于接收键盘录入的
  • 静态什么时候用?

静态变量

当分析对象中所具备的成员变量的值都是相同时,这时这个成员就可以被静态修饰。

只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。

如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。

静态函数

函数是否用静态修饰,就参考一点,就是该函数功能是否需要访问到对象中的特有数据。

简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。

如果不需要,就可以将该功能定义成静态的。当然,也可以定义成非静态,但是非静态需要被对象调用。

如果没有访问特有数据的方法,该对象的创建是没有意义。

/*
main方法的格式讲解:
public static void main(String[] args) {...}

public:公共的,访问权限是最大的。由于main方法是被jvm调用,所以权限要够大。
static:静态的,不需要创建对象,通过类名就可以。方便jvm的调用。
void:因为我们曾经说过,方法的返回值是返回给调用者,而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。我见过的语言都是以main作为入口。
String[] args:这是一个字符串数组。值去哪里了?
这个东西到底有什么用啊?怎么给值啊?
这个东西早期是为了接收键盘录入的数据的。
格式是:
java MainDemo hello world java
*/
class MainDemo {
public static void main(String[] args) {
//System.out.println(args); //[Ljava.lang.String;@175078b
//System.out.println(args.length); //0
//System.out.println(args[0]); //ArrayIndexOutOfBoundsException

//接收数据后
System.out.println(args);
System.out.println(args.length);
//System.out.println(args[0]);
for(int x=0; x<args.length; x++) {
System.out.println(args[x]);
}
}
}

运行结果:

面向对象(二)-搞定她-搞定程序_多态_08

静态函数

修饰符

面向对象(二)-搞定她-搞定程序_封装_09

java修饰符

关键字

面向对象(二)-搞定她-搞定程序_java_10

java关键字

举报

相关推荐

0 条评论