封装与参数、this Static关键字 构造器 块
1.构造器
*
* new关键字做的事情:
* 1.在堆中为这个对象开辟空间,并且成员属性|变量会跟随对象进入到堆内存中,并附默认值
* 2.调用构造器,对对象初始化信息
* 3.将地址返回给引用
*
* 构造器|构造方法|构造函数:
* 构造器就是一个特殊的方法
* 作用:为对象初始化信息
* 定义:
* 修饰符 类名(参数列表){
* 方法体;
* }
* 构造器的方法名必须与类名保持一致
* 构造器不需要定义返回值类型和void,可以没有return
* 根据需要定义return,提前结束方法|构造器的作用
*
* 注意:
* 如果没有显示的定义构造器,编译器会自动为你提供一个空构造(参数为空的构造器)
* 如果有显示定义构造器,编译器都不会在为你提供任何构造器了
*
* 构造器也是一个方法,就拥有方法重载的特性,可以构成方法的重载
* 构造器不能和abstract,static,final一起使用
*
*
* 构造器不是创建对象使用的,是为对象初始化信息用的
* 如果创建对象的同时就能够确定所有属性|某些属性的值,可以选择使用带参构造,创建对象的同时赋值,简单
* 如果创建对象的时候不确定属性值,可以选择是使用空构造,后续知道值的时候再通过对象.属性为某个属性赋值
* 只要创建对象肯定途中会调用构造器
*
* 建议:
* 如果以后定义这种自定义的模板类,至少提供一个空构造
2.参数
定义方法()中的参数:形式参数(形参) 变量的声明
调用方法()中的参数:实际参数(实参) 变量的赋值
形参和实参之间需要一一对应
3.this 关键字
/*
* this 代表当前创建对象,存储当前对象的地址
* 在构造器的首行调用本类中的其他构造器
* this(参数列表)
* 必须定义在构造器首行
* 构造器之间不能通过this相互调用
在成员方法|构造器中用来区分同名变量问题
成员变量和局部变量之间同名问题
默认就近原则,如果想要指代成员,通过this调用成员 this.name
如果不存在同名问题,使用成员,this.可以省略,直接写成员的名字,如果出现同名不能省略,如果省略就会发生就近原则
*
* 构造器只能跟随new一起使用,不能调用,但是可以通过this
* this不能和static一起使用
*/
public class ThisDemo01 {
public static void main(String[] args) {
Person p=new Person("张三",18,false,"程序猿");
p.info();
System.out.println(p);
}
}
class Person{
public String name;
public int age;
public boolean gender; //false->男 true->女
public String occupation; //职业
public Person() {
// TODO Auto-generated constructor stub
}
//就近原则 谁离我进我找谁
public Person(String name, int age,boolean gender) {
//参数接收到的值,实参值赋值给对象成员变量
this.name=name;
this.age=age;
this.gender=gender;
}
public Person(String pname, int page,boolean pgender,String poccupation) {
//把当前构造器接收到的参数值,传递给调用的其他构造器,简化代码
this(pname,page,pgender);
occupation = poccupation;
}
public void info(){
//局部变量
String name="哈哈";
System.out.println(this.name+","+this.age+","+gender+","+occupation);
System.out.println(this);
}
}
5.Static关键字
/*
* static 关键字
* 静态的,静态的内容是属于类的,成员是属于对象的
* static修饰变量: 静态变量|类变量
* static是一个成员修饰符,只能用来修饰成员,不能用来修饰局部
*
* static修饰方法: 静态方法|类方法
* 静态的内容的使用方式:
* 1.类名.静态变量名 | 类名.静态方法名()
* 2.对象.静态变量名 | 对象.静态方法ing()
*
* 注意:
* 静态都是属于类的,都会在类第一次加载完成之后初始化一次,静态的变量会在静态区中存在,多个对象共享的
* 静态的内容中,可以直接使用静态的内容,不可以直接使用非静态的内容,但是可以通过对象使用
* 成员的内容中,可以直接使用静态的内容,可以直接使用非静态的
*/
public class StaticDemo01 {
//成员变量
public int id=5;
//静态变量
static int age=10;
//成员方法
public void test1(){
System.out.println("我是一个成员方法");
System.out.println(id);
System.out.println(age);
}
//静态方法
public static void test2(){
System.out.println("我是一个静态方法");
//System.out.println(this); 因为静态的方法在调用之前可以能没有对象,找不到对象,多以this不能使用
}
public static void main(String[] args) {
//static int a=5; //局部变量
StaticDemo01 demo=new StaticDemo01();
System.out.println(demo.id); //通过对象使用成员
System.out.println(age); //因为在本类中
System.out.println(StaticDemo01.age); //通过类名使用静态变量
System.out.println(demo.age); //通过对象使用静态变量
demo.test1(); //成员方法
demo.test2(); //静态方法
StaticDemo01.test2();
System.out.println();
}
}
6.封装
/*
* 安全隐患问题: 有些数据的值,不符合生活逻辑
* 介绍一个关键字 private 私有的
* private 成员修饰符,只能修饰成员,不能修饰局部
* 私有的内容,只能在本类中使用,外部类中无法使用
* 私有的属性,需要配合设置器和访问器一起使用--> 公共的访问方式
* 设置器setter和访问器getter 是一个方法,是公共的
*
*
* 封装:
* 隐藏内部的实现细节,对外提供公共的访问方式
*
* 封装的好处;
* 1.提高程序的安全性
* 2.提高代码的复用性(类,方法..)
*
* 属性私有化,配和公共的访问方式->是java中面向对象封装的一种具体的体现
* 私有是封装 对
* 封装是私有 错 因为:不仅仅是私有,还有方法,类..都是封装的体现
*
* 以后再定义这中模板类的代码:(Student,Person,Car,Phone...),这系列类统称都是javabean类
* 标准的javabean定义规范:
* 1.类的公共的
* 2.至少提供一个空构造
* 3.属性全部私有
* 4.并提供公共的访问方式
*/
public class javaBeanDemo {
public static void main(String[] args) {
Person p=new Person();
p.name="yinwei";
//p.age=-18;
p.setAge(9);
p.info();
System.out.println(p.getAge());
}
}
class Person{
public String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//age属性的设置器
public void setAge(int age){
if(age>=0){
this.age=age;
}else{
System.out.println("年龄不合法");
this.age=18;
}
}
//age属性的访问器
//返回值:要 int 参数
public int getAge(){
return this.age;
}
public void info(){
System.out.println(name+"-->"+age);
}
}
7.块
/*
* block 块 {}-->作用域
* {}->放在方法中->局部代码块|普通语句块 执行时机:跟随方法,放方法被调用的时候执行
* {}->类中方法外部->构造块 执行时机:创建对象
* static{}->类中方法外->静态块 执行时机:类加载
*
* 构造块中的内容,在编译的时候,会被编译到要执行的构造器代码之前,如果存在多个构造块从上倒下一次执行
* 静态块的内容只会执行一次,在类第一次加载之后执行,并且只有一次,如果存在多个静态块从上倒下一次执行
*
* static-->main-->构造块->构造器
*/
