----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------
封装:是指隐藏对象的属性和实现细节,仅对外提供公共的访问方式。
好处:将变化隔离。便于使用。提高重用性。提高安全性。
封装原则:将不需要对外提供的内容都隐藏起来。把属性都隐藏,提供公共方法对其访问。
Private:关键字,权限修饰,用于修饰成员(成员变量,成员函数),私有化的数据只在本类中有效。其他程序创建的对象是无法直接访问的。但是为了便于其他类对其访问,可以对外提供一些公共方法来完成。例:
class Person
{
private int age;//只在本类中有效,不能被其他对象直接访问了
public void setAge(int age)//提供了对外的公共方法
{
this.age=age;
System.out.println(this.age);
}
}
class Demo
{
public static void main(String[] args)
{
Person p=new Person();
p.setAge(12);
}
}
这里setAge: 方法名和变量名写法规范:一个单词组成的名称,所用的字母小写。多个单词的话,第一个单词都是小写,从第二个开始,每个单词的首字母都大写。
通常情况下,会将类中的成员变量私有化,为了避免属性直接被访问导致数据错误,对外提供了公共的访问方式,对该属性进行访问。好处:对属性进行可控。对属性访问的公共方法名称定义格式:set属性()、get属性()。若对象中有10个属性,一般则至少有20个方法,因为每个属性通常都对应两个方法:set属性();get属性()
注意:私有仅仅是封装的一种体现形式之一。
函数就是一个最小的封装体。类本身也是一种封装。
二、构造函数
特点:1、函数名与类名相同。2、不用定义返回值类型。3、没有具体的返回值。
创建的每个对象都是一个实体,而每个实体都必须要进行初始化后才可以使用。构造函数的作用就是给对象初始化。
任何用class定义的类中,都有一个默认的空参数的构造函数。用于给该类对象进行初始化。如果该类中指定了具体的构造函数,那么默认的构造函数就没有了。
构造函数和一般函数的区别:
1、书写格式不同。2、运行上的不同。构造函数是在对象创建时就被调用了,而且只执行一次。一般函数是在对象创建完后,所需时才会被调用,可以被调用多次。
构造函数是有return语句的,用于结束构造函数的初始化动作。
当一个类中存在多个构造函数时,它们的存在形式是重载。
多个构造函数意味着多种初始化方式,这就要根据对象创建时的参数列表来找到与之对应的初始化方式。比如:
class Person
{
private String name;
private int age;
Person(int age)//构造函数1
{
this.age=age;
}
Person(String name,int age)//构造函数2
{
this.name=name;
this.age=age;
}
}
class Demo
{
public static void main(String[] args)
{
Person p=new Person("zhangsan",22);//根据参数列表,选择了构造函数2.
Person p=new Person();//是错误的,因为默认的构造函数已经没有了。
}
}
构造函数什么时候用?
当描述事物时,该事物一存在,就具备着一些属性和行为。那么,就将这些内容定义在构造函数中。对象的初始化
new Person("lisi");
new:用于在堆内存中开辟空间的关键字,用于创建对象。
Person:明确要创建Person类的对象,即在指定的目录下找Person.class文件,只要该文件存在就会立刻加载进内存。
"lisi":创建Person类的对象,需要通过哪个构造函数来进行初始化。这里需要用到一个字符串参数的构造函数。
this关键字
当成员变量和局部变量同名的时候,为了区分,可以使用一个关键字来完成.this.name=name;
this代表的是一个对象,哪个对象调用了this所在函数,this就代表哪个对象(被引用的当前对象)
this 什么时候用?
当定义功能时,功能内部使用了调用该功能的对象,这时就用this来表示。
需求:在Person类中定义一个比较方法,判断是否是同龄人。
明确结果:boolean
明确未知内容:Person(因为是一个任意一个Person对象比较其中的年龄)
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public boolean compare(Person p)
{
return this.age==p.age;//当前对象this和传入对象p进行年龄的比较。
}
}
class CompareDemo
{
public static void main(String[] args)
{
Person p1=new Person("zhangsan",22);
Person p2=new Person("lisi",22);
boolean b=p1.compare(p2);
System.out.println(b);
}
}
this 表现形式:1、this.name=name;
2、this在对象初始化完毕后,才可以使用。构造函数之间的调用可使用this来完成。后面跟上(),指定具体的实参,即明确要调用的构造函数。
构造函数的调用方式:函数调用本类中构造函数的this语句必须定义在构造函数的第一行语句。因为初始化动作要先完成。
class Person
{
private String name;
private int age;
Person(int age)
{
this.age=age;
}
Person(int age,String name)
{
this(age);对Person(int age)构造函数的调用
this.name=name;
System.out.println(name+":::"+age);
}
}
如果写成
Person(int age,String name)
{
this.name=name;
this(age);是错误的。
}
局部代码块:控制变量的生命周期。
构造代码块:它可以对所有的对象进行初始化。构造函数是对对应的对象进行初始化。
它们没有任何关键字标识
public static void main(String[] args)
{
{int x=9;}
System.out.println(x);//是错误的。找不到符号x
}
而构造代码
class Person
{
private String name;
private int age;
{
System.out.println("cry");//这便是构造代码
}
Person(int age)
{
this.age=age;
System.out.println(age);
}
}
class CompareDemo
{
public static void main(String[] args)
{
Person p1=new Person(12);
Person p2=new Person(9);
}
}结果是cry 12 cry 9
三、static(静态)关键字
1、被static修饰的成员变量,被所有的对象所共享。
方法区(共享区):凡是被对象所共享的数据都在这片区域中。
2、静态随着类的加载而加载,消失而消失。
3、优先于对象存在
4、静态成员可以被直接被类所调用
class Person
{
private int age;
static String country="CN";
}
class Demo
{
public static void main(String[] args)
{
System.out.println(Person.country);直接被类所调用。
}
}
特有数据:存储在对象中的数据。如上述代码中Person类中的age
共享数据:static
Static的使用注意事项:
1、静态方法只能调用静态成员,不能调用非静态成员。
非静态方法可以调用静态成员,也可以调用非静态成员。
2、在静态方法中不允许出现this、super关键字。因为this代表对象,而静态方法执行时还没有对象呢。
静态数据先于非静态数据,所以静态方法不能调用非静态数据。
3、主函数是静态的。静态是有访问局限的,只能调用静态的内容。
静态成员变量和非静态成员变量的区别:
1、非静态成员变量又称为实例(对象)变量。
静态成员变量又称为类变量(可以直接被类名直接调用的变量)
2、非静态成员变量随着对象的创建而存在,消失而消失。
静态成员变量随着类的加载而加载,随着类的消失而消失。
3、非静态成员变量存在于对象的堆内存中。
静态成员变量存在于方法区中。
4、非静态成员变量只能被对象调用
静态成员变量可以被类名调用,也可以被对象调用。
静态什么时候用?
1、成员变量是否需要被static修饰,该成员变量的值是否对每一个对象是相同的。若是,用static修饰,被对象共享。若不是,不用static修饰,让这些存储到每个对象中。
2、成员函数是否被静态修饰?当函数中访问到了对象的特有属性时,该函数不能被静态所修饰。简单说,就是如果函数中访问了成员变量(实例变量)就不能静态修饰了。否则可以静态化。
如果一个类中定义的方法都是静态的,说明这个类是不需要对象的。所以在本类中,加入一些强制措施:private 类名(){}即将构造函数私有化,这样其他程序就无法创建该类的对象了。
静态代码块:
static
{
code----
}
特点:随着类的加载而执行,且只执行一次。
优先于主函数执行。
作用:给类初始化。示例如下:
class Person
{
static
{
System.out.println("fuck");//静态代码块
}
private int age;
static String country="CN";
}
class Demo
{
public static void main(String[] args)
{
System.out.println(Person.country);
}
}结果是 fuck CN
栈内存是方法的运行区而非存储区。
调用成员的两种方式:1、用类名调用,但前提是被调用的成员须是静态的。2、用对象来调用。看看下面的小例子们:
1、class Demo
{
int x=6;
public static void main(String[] args)
{
System.out.println("x="+new Demo().x);
}
}若没有下划线部分,就相当于在静态的主函数方法里调用了非静态的x变量,编译报错找不到符号x。这里的下划线部分就是用Demo对象来调用的。因为Demo对象里有x变量。或者不添加下滑线部分,将非静态变量x前加static修饰变为静态成员变量可被静态方法调用。
2、class Demo
{
int x=6;
public static void main(String[] args)
{
new Demo().show();
}
public void show()
{
System.out.println("x="+x);
}
}通过对象调用的方式。new Demo()创建的对象实体中既有了所要调用的函数show()也有了实例成员变量x。若把int x=6;移到main函数中,意味着Demo对象实体中就没有了实例变量x,则会编译报错找不到符号x。
3、class Person
{
static int x=2;
}
class Demo
{
public static void main(String[] args)
{
System.out.println(Person.x);
}这里便是通过类名直接调用静态的x变量
}
----------------------- android培训、java培训、java学习型技术博客、期待与您交流! ----------------------