面向对象（二）-搞定她-搞定程序
面向对象（一）-搞定她-搞定程序
封装(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());}
}
运行结果：
this关键字
this关键字的内存图解：
this关键字
构造方法
构造方法作用概述：给对象的数据进行初始化
构造方法格式
- 方法名与类名相同
- 没有返回值类型，连void都没有
- 没有具体的返回值
构造方法注意事项
- 如果你不提供构造方法，系统会给出默认构造方法
- 如果你提供了构造方法，系统将不再提供
- 构造方法也是可以重载的
给成员变量赋值有两种方式
- setXxx()
- 构造方法
PS：
- 一般函数和构造函数什么区别呢？
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。
构造函数：对象创建时，会调用并且只调用一次。
一般函数：对象创建后，可以被调用多次。
- 创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。
多个构造函数是以重载的形式存在的。
/**
我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?构造方法的注意事项: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("-------------");//创建对象2Student s2 = new Student("林青霞");s2.show();System.out.println("-------------");//创建对象3Student s3 = new Student(27);s3.show();System.out.println("-------------");//创建对象4Student 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();}}
运行结果：
类的成员方法
2.11 类的初始化过程
Student s = new Student();在内存中做了哪些事情?
- 加载Student.class文件进内存
- 在栈内存为s开辟空间
- 在堆内存为学生对象开辟空间
- 对学生对象的成员变量进行默认初始化
- 对学生对象的成员变量进行显示初始化
- 通过构造方法对学生对象的成员变量赋值
- 学生对象初始化完毕，把对象地址赋值给s变量
类的初始化过程
static关键字
static关键字可以修饰成员变量和成员方法
static关键字特点
- 随着类的加载而加载
- 优先于对象存在
- 被类的所有对象共享
- 这也是我们判断是否使用静态关键字的条件
- 可以通过类名调用
static关键字注意事项
- 在静态方法中是没有this关键字的
- 静态方法只能访问静态的成员变量和静态的成员方法
静态的内存图
静态的内存图
静态变量和成员变量的区别
静态变量和成员变量的区别
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]);}}}
运行结果：
静态函数
修饰符
java修饰符
关键字
java关键字
浅浅的花香味﹌
野性酷女
深藏阁楼爱情的钟
àì夳堔傛蜴生んèń
还没有评论，来说两句吧...