![[ java基础 ] 面向对象: 封装.javaBean.this](http://www.mshxw.com/aiimages/31/736913.png "[ java基础 ] 面向对象: 封装.javaBean.this")
面向对象OOP(Object Oriented Progarmming)
特点:面向对象的语言中，包含了三大基本特征，即封装、继承和多态。
类和对象
类:是一类事物的"属性"和"行为"的集合
属性:状态信息行为:行为动作
类和对象的关系:
类是对象的模版,抽象对象是类的实体,实例
类的设计:
需要将以前的代码进行拆分:
a.标准类:创建对象的类
b.测试类:含有主方法的类
程序中标准类的分类
a.API源码提供的类(Java系统提供的类)
b.自定义类
类的设计过程:
1.在类中添加实例成员,完成基础类的设计(基础类是标准类的雏形)
2.在基础类的标准上,添加"封装"思想
3.在基础类的标准上,添加"构造器"的概念,完成JavaBean(标准类)设计
4.在标准类的标准上,添加"静态"的概念
5.在标准类的标准上,添加"继承"思想
6.在标准类的标准上,添加"抽象"的概念
7.在标准类的标准上,添加"接口"的概念
8.在标准类的标准上,添加"内部类"的概念
9.在标准类的标准上,添加"代码块"的概念
类的定义:定义类的成员,包括实例变量和实例方法。
类的格式:
public class 类名 {
实例变量
实例方法
}
成员变量(全局变量):声明在类中方法外的变量,包含实例变量和静态变量
实例变量:声明在类中方法外,且没有static关键字修饰的变量,因为实例变量属于对象,所以也叫对象变量
静态变量:声明在类中方法外,且含有static关键字修饰的变量,因为静态变量属于类,所以也叫类变量(明天讲解)
成员方法
实例方法:声明在类中且没有static关键字修饰的方法,因为实例方法属于对象,所以也叫对象方法
静态方法:声明在类中且含有static关键字修饰的方法,因为静态方法属于类,所以也叫类方法(明天讲解)
对象：是一类事物的具体体现。对象是类的一个实例,必然具备该类事物的属性和行为。
对象的创建
格式:
类名 对象名=new 类名( );
使用对象的属性:
对象名.属性名
调用对象的方法
对象名.方法名(实参);
学生类的设计:
public class Student {
//实例变量
String name;
int age;
//实例方法
public void study () {
System.out.println(age + "岁" + name + "正在good good study , day day up !!!");
}
}
测试类:
public class OOPDemo01 {
public static void main(String[] args) {
//创建学生对象
Student s1 = new Student();
System.out.println(s1);//com.atguigu.oop.demo01.Student@1b6d3586
//获取对象的属性
System.out.println(s1.name);//null
System.out.println(s1.age);//0
//给对象的属性进行赋值
s1.name = "崔小荣";
s1.age = 18;
//获取对象的属性
System.out.println(s1.name);//崔小荣
System.out.println(s1.age);//18
//调用学生的study()
s1.study();//18岁的崔小荣正在good good studydaydayup!!!
System.out.println("===========================================");
//创建第二个学生对象
Student s2 = new Student();
s2.study();//0岁的null 正在......
}
}
对象使用的内存图解<==========================
方法区中运行demo文件=>加载未知数据类型,运行Student文件=>栈中运行主方法=>创建对象s1=>堆中创s1地址值,指向对象=>调用s1对象的方法(s1.study),调用完即结束=>s2同理
局部变量个实例变量的区别
局部变量:声明在方法内部或者方法声明上的变量
实例变量:声明类中方法外,且没有static关键字修饰的变量
区别
代码中的位置不同:
局部变量:方法内部或者方法声明上(形参)实例变量:类中,方法外 内存中的位置不同
局部变量:栈内存实例变量:堆内存 默认值的不同:
局部变量:没有默认值实例变量:有默认值 代码中的作用域不同:
局部变量:方法中实例变量:类中(静态方法和静态代码块除外) 内存中的生命周期不同:
局部变量:随着方法的调用而加载,随着方法的出栈而消失实例变量:随着对象的创建而加载,随着对象的消失而消失 this关键字第一种用法
应用场景:(子)类中的实例方法或者(子)类中的构造器
格式:
this.实例变量名
this.实例方法名(实参);
作用:用来区分同一个类中同名的实例变量和局部变量
含义:哪个对象调用了this所在的方法或者构造器时,this关键字就代表哪个对象
变量类:
public class Var {
//同名的实例变量
int num = 10;
//同名的局部变量
public void method () {
int num = 20;
System.out.println("num = " + num); //20 就近原则
System.out.println("num = " + this.num); //10
}
public void show() {
System.out.println("this = " + this);
}
}
测试类*:
public class OOPDemo03 {
public static void main(String[] args) {
//创建Var对象
//Var var = new Var();
//var.method();
//创建两个Var对象
Var v1 = new Var();
System.out.println("var1 = " + v1);//var1=com...3586
v1.show//this=com...3586
Var v2 = new Var();
System.out.println("var2 = " + v2);//var2=com...4617c
v2.show//this=com...4617c
}
}
封装
封装:就是将标准类中实现细节(成员变量)隐藏起来,对外提供公共访问方式
四种权限访问级别:public > protected > 缺省 > private
封装思想的特点:四种权限访问级别的体现
封装的好处:增加程序的安全性
private关键字:
含义:私有的
作用:被private修饰的变量或者方法只能在本类中进行访问,不能在外界进行访问
格式:
private 数据类型 变量名;
private关键字的使用步骤:
1.将类中的成员变量全部进行私有化
2.针对每个被private关键字修饰的成员变量提供一对公共的访问方式
举例:我去银行存钱和取钱
功能:存钱
返回值类型:void
形参列表:钱
功能:取钱:
返回值类型:钱
形参列表:无
学生类:
public class Student {
//实例变量
private String name;
private int age;
//存储姓名
public void setName (String n) {//n===>name
name = n;//this.name = name;
}//用this对学生类进行优化
//获取姓名
public String getName () {
return name;
}
//存储年龄
public void setAge (int a) {//a===>age
age = a;//this.age = age;
}
//获取年龄
public int getAge () {
return age;
}
//实例方法
public void study () {
System.out.println(age + "岁" + name + "正在good good study , day day up !!!");
}
}
测试类
public class OOPDemo04 {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//给学生对象进行赋值
//给学生对象进行赋值
s.setName("崔小荣");
s.setAge(-18);
s.study();//System.out.println(s.getName() + "=" + s.getAge());//this优化版
}
}
构造器
构造器:又称为构造方法,格式和方法类似
构造器格式:
修饰符 类名 () {}
构造器的作用:
1.隐式部分,完成对象的初始化过程(暂不涉及,day12进行讲解)
2.显式部分,给对象的实例变量进行赋值操作(有参构造器)
*注意:隐式部分代码优先于显式部分代码执行
构造器的注意事项:
1.当一个类没有任何构造器时,JVM自动提供一个默认无参的构造器,一旦这个类有任何的构造器,JVM不在为其提供2.构造器也支持重载3.构造器名必须和类名相同4.构造器没有返回值类型,而且连void都不能有(如果加上void则为普通的方法)5.在实际开发中,类中的__无参构造器建议写上__,不建议通过JVM进行提供(否则加上有参构造器时,若new一个对象会报错) 构造器和公共访问方式对比
给私有化实例变量赋值的方式有2种
(1)封装思想中set()
(2)有参构造器
*注意:都可以给实例变量进行赋值,构造器针对对象有初始化过程,set()没有
获取实例变量的方式有1种
获取实例变量的方式有1种===>封装思想中get()
学生类:
public class Student {
private String name;
private int age;
//存储姓名
public void setName (String name) {
this.name = name;
}
//存储年龄
public void setAge (int age) {
this.age = age;
}
//有参构造器
public Student (String name, int age) {
this.name = name;
this.age = age;
}
}
javaBean标准类的设计
一种约定俗成设计类的标准,要求类必须是具体的和公共的
设计要求
类必须声明public,一个.java文件中只允许一个类
必须有:
(1)私有化成员变量(2)针对每个私有化成员变量对外提供公共的访问方式get()和set()(3)无参构造器
可以有:
(1)合适有参构造器
(2)特殊的实例方法:
toString()
hashCode()
equals()
(3)构造器代码块
(4)静态代码块
(5)内部类
代码自动生成__快捷键__:Alt + Ins(ert)
标准类
public class Student {
//私有化实例变量
private String name;
private int 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 Student() {
}
//满参构造器
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
测试类
public class OOPDemo08 {
public static void main(String[] args) {
//通过无参的构造器创建对象
Student s1 = new Student();
//给学生对象进行赋值
s1.setName("崔小荣");
s1.setAge(18);
System.out.println(s1.getName() + "=" + s1.getAge());
System.out.println("===============================");
//通过满参的构造器进行对象的创建
Student s2 = new Student("崔大荣", 19);
System.out.println(s2.getName() + "=" + s2.getAge());//?
}
}
匿名对象
匿名对象:没有名字的对象
特点:只能使用唯一的一次
测试类:
public class OOPDemo09 {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();//学生对象s需要在main()出栈后,才被认定为垃圾数据
printStu(s);
printStu(s);
System.out.println("===================================");
//换一种写法(匿名)
printStu(new Student()); //学生对象需要在printStu()出栈后,才被认定为垃圾数据
printStu(new Student());
//后续还有其他代码
System.out.println("后");//直接调用同匿名
System.out.println("续");
System.out.println("代");
System.out.println("码");
}
public static void printStu (Student s) {
System.out.println(s);
}
}
对象数组
对象数组:存储对象的数组
标准类:见javabean
测试类:
注意*:所有的实例变量私有化后，如果想在其他类访问该类实例变量必须定义get/set方法
public class OOPDemo10 {
public static void main(String[] args) {
//创建基本数据类型数组
int[] arr01 = {11,22,33};
//创建String类型数组
String[] arr02 = {"a","b","c"};
//创建学生类型数组
Student s1 = new Student("崔小荣", 18);
Student s2 = new Student("张小芳", 18);
Student s3 = new Student("安小妮", 18);
Student s4 = new Student("张小弛", 18);
Student s5 = new Student("李小朦", 18);
Student[] arr03 = {s1,s2,s3,s4,s5};
for (int i = 0; i < arr03.length; i++) {
Student s = arr03[i];
System.out.println(s.getName() + "=" + s.getAge());
}
}
}
类中私有方法
特点:只能在本类中进行访问,无法在外界进行调用
格式:
private 返回值类型 方法名 () {}
public class OOPDemo11 {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
s.method01();
System.out.println("====================");
s.method02();
System.out.println("====================");
//s.method();
}
}
public class Student {
public void method01 () {
method();
System.out.println(5);
}
public void method02 () {
method();
System.out.println(8);
}
private void method () {
System.out.println(1);
System.out.println(2);
System.out.println(3);
}
}
构造器代码块
作用:当多个构造器中含有相同的代码时,可以将相同代码放到构造器代码块中,构造器代码块优先于构造器的显示代码执行
格式:
{
构造器中相同代码
}
*注意:
隐式代码:调用构造器代码块
代码:
public class Student {
private String name;
private int age;
public Student () {
//隐式代码:调用构造器代码块
System.out.println(5);
}
public Student (String name , int age) {
//隐式代码:调用构造器代码块
System.out.println(8);
}
{
System.out.println(1);
System.out.println(2);
System.out.println(3);
}
}
public class OOPDemo12 {
public static void main(String[] args) {
new Student();//1235
System.out.println("============");
new Student("" , 1);//1238
}
}
this关键字第二种用法
应用场景:(子)类中的构造器
格式:
this(实参);
作用:当构造器无法进行初始化(隐式代码)时,需要将初始化工作"外包"给其它的构造器
注意事项:
1.构造器无法递归
2.this(实参)必须写在构造器中的第一行
代码:
public class OOPDemo13 {
public static void main(String[] args) {
new Student();//4行
}//只new了一个对象,所以隐式代码(构造器代码块)只走了一次,则调用隐式代码次数等于new的次数
}
public class Student {
public Student() {
this(1);
System.out.println("无参构造器");
}
public Student (int a) {
this(1,2);
System.out.println("一个参数的构造器");
}
public Student (int a, int b) {
//隐式代码//有能力初始化才能调用隐式代码(构造器代码块)
System.out.println("两个参数的构造器");
}
{
System.out.println("构造器代码块");
}//若没有构造器代码块,则结果为两个ln(换行)一个ln无
}
