JAVA--基础前言开发

Day06【java基础类与对象、封装、构造方法】

1.1成员变量和局部变量

1成员变量: 也称为全局变量(属性)。

a变量根据定义的位置不一样，分为全局变量(成员)和局部变量。

1. 全局变量：定义在类中，任何方法的外面。
2. 局部变量: 定义在方法中或者方法的参数（形参），以及谋个代码块中。

b做用的范围不同

1. 成员变量:在整个类中均可以使用。
2. 局部变量:在方法中或者某个代码块中。

c初始值得不一样

1. 成员变量:有默认值得。
2. 局部变量:没有默认值，必须初始化了以后才可使用。

d在内存中的位置不一样

1. 成员变量:堆内存中。
2. 局部变量:栈内存中。

e 生命周期的不一样

1. 成员变量:随着对象的建立而存在,随着对象的消失而消失。
2. 局部变量:随着方法的调用而存在，随着方法的调用完毕而消失。

区分变量的做用域:能够根据，离它最近的大括号以及匹配的结束大括号，其实就是这个变

量的活动区域。

【第三章】封装

封装：能够认为是一个保护屏障，防止该类的代码和数据被其余的类随意访问。要访问该类的数据，必须经过指定的方式，适当的封装可让代码等容易理解和维护，也增强的代码的安全性。

封装：就是对抽取出来的数据进行包装。他的目的：就是提升数据的安全性。

封装包括两个方面的封装: a、(特征)属性的封装 b、(行为)方法的封装。

可是封装起来的数据并非绝对的封装，若是有其余的程序须要访问，能够经过指定的入口来访问。属性的封装和方法的封装是相辅相成的二者密不可分。

原则：将成员属性隐藏起来，若须要访问某个属性，能够提供公共的方法对其访问。

1.2 类之间方法和属性的相互调用

public class TestA {     String  name;     int  age;     String address;     public  void  displayA(){         System.out.println("这个TestA中的display方法");     }     public static void main(String[] args) {        //建立TestB的对象         TestB testB=new TestB();         testB.stuName="王智雅";         testB.stuAge="22";         testB.stuXueli="大学";         testB.display();         System.out.println(testB.stuName);         System.out.println(testB.stuAge);         System.out.println(testB.stuXueli);     } } public class TestB {     String stuName;     String stuAge;     String stuXueli;     public  void display(){         System.out.println("这是TestB中的display方法");     }       public static void main(String[] args) {         //建立TestA中的对象         TestA  testA=new TestA();         testA.name="杨路华";         testA.age=23;         testA.address="河南";         testA.displayA();         System.out.println(testA.name);         System.out.println(testA.age);         System.out.println(testA.address);     } }

1.3封装的操做步骤：

1.3.1使用private关键字来修饰成员变量

1. Private 是一个权限修饰符，表明最小权限，只能在当前类中访问Private修饰的属性。
2. Private能够修饰成员变量和成员方法。
3. 被Private修饰的成员变量和成员方法只能在本类中才能访问。

Private 的使用格式：

1. 修饰成员属性 ：Private  数据类型  变量名；
2. 修饰成员方法 ：Private  返回值类型  方法名(参数列表);

一、示例，Private 修饰的成员的变量：

Private  String  name; Private   int  age;

2、示例，Private 修饰的成员方法：

Private  String  Message(){} Private   void  display(int  a,int  b){}

三、代码示例：

//设置private 来修饰成员变量 public class TestC {     private String  name;     private int  age;     private String address; //提供公共的set==get方法来设置，获得属性的值     public void setName(String  n){//设置属性值         name=n;     }     public String getName(){//获得属性值         return name;     }     public void  setAge(int a){         age=a;     }     public  int getAge(){         return age;     }     public void setAddress(String ss){         address=ss;     }     public String getAddress(){         return address;     }     public  void  displayA(){         System.out.println("这个TestA中的display方法");     }     public static void main(String[] args) {         //建立TestB的对象         TestD testD=new TestD();         //经过set方法来设置属性的值         testD.setStuName("王智雅");         testD.setStuAge("23");         testD.setStuXueli("大专");         testD.display();         //经过get方法来获得属性的值         System.out.println(testD.getStuName());         System.out.println(testD.getStuAge());         System.out.println(testD.getStuXueli());     } }     public class TestD {     private String stuName;     private String stuAge;     private String stuXueli;     //提供公共的set方法，get方法来获得属性的值     public void setStuName(String Name){         stuName=Name;     }     public  String getStuName(){         return  stuName;     }     public  void setStuAge(String  age){         stuAge=age;     }     public  String  getStuAge(){         return stuAge;     }     public void  setStuXueli(String xueli){         stuXueli=xueli;     }     public  String getStuXueli(){         return stuXueli;     }       public  void display(){         System.out.println("这是TestB中的display方法");     }       public static void main(String[] args) {         //建立TestA中的对象         TestC  testC=new TestC();         //经过setName来设置属性的值         testC.setName("李文杰");         testC.setAge(23);         testC.setAddress("兰州");         testC.displayA();         //经过getName来获得属性的值         System.out.println(testC.getName());         System.out.println(testC.getAge());         System.out.println(testC.getAddress());     } }

 

4.总结:

若是给成员变量设置了私有的Private 属性以后，若是咱们还想继续访问该私有的属性，则能够经过公共的方法来

访问该属性的值，则能够经过公共的set方法来给属性设置值，经过get 方法获得属性的值。

1.3.2 构造方法

建立对象的语法：类名 对象名=new 类名();

当建立一个类的对象时，其实就是经过构造方法来建立的。New后面的就是构造方法。

那么构造方法的定义语法:

[访问修饰符]  类名(参数表列){   }

1. 构造方法的分析:

1. 构造方法的方法名必须和类名相同。
2. 构造方法没void类型,也不能有返回值。
3. 构造方法不能被static 关键字所修饰。

1. 构造方法的做用:

1. 构造方法用来建立对象。
2. 对成员属性进行初始化。

1. 针对构造法方法的第一个做用示例:

//构造方法 public class Test3 {     public Test3(){         System.out.println("这是Test3中的无参数构造方法");     }     public static void main(String[] args) {       //建立当前类对象         Test3  t=new Test3();     } }   解析:也就是说在建立对象的时候，new 后面的就是构造方法。若是有构造方法，则他会执行构造方法中的代码。

1. 针对构造方法的第二个做用示例:

//构造方法 public class Test3 {     String  name;     String  xueli;     public Test3(){         name="张三";         xueli="本科";         System.out.println("这是Test3中的无参数构造方法");     }     public static void main(String[] args) {       //建立当前类对象         Test3  t=new Test3();         System.out.println(t.name);         System.out.println(t.xueli);     } } 解析:也就是说构造方法也能够对成员变量进行初始化。

1.3.3  构造方法的分类:

1构造方法的分类:

1. 有参的构造方法.
2. 无参的足构造方法(默认的构造方法)。

1. 无参的构造方法分为：

1. 隐式的无参的构造方法
2. 显示的无参的构造方法。

1. 在一个类中，不存在任何形式的构造方法时，jvm就会为当前类提供一个默认的隐式无参的构造方法。
2. 那么显示无参的构造方法就是程序猿自定义的构造方法。
3. 当一个类中已经存在了一个构造方法（不管有参仍是无参的），那么JVM就不会在提供那个隐式无参的构造方法。
4. 在一个类中能够提供多个构造方法，只须要参数列表不一样便可，构造方法能够进行方法的重载。根据参数列表匹配。

• 构造方法的示例:

//构造方法 public class Test3 {     String  name;     String  xueli;     //构造方法     public Test3(){         //对成员属性进行初始化         name="张三";         xueli="本科";         System.out.println("这是Test3中的无参数构造方法");     }     //有参数的构造方法     public  Test3(String  stuname,String score){         name=stuname;         xueli=score;         System.out.println("======有参数的构造方法=======");     }     public static void main(String[] args) {       //建立当前类对象         Test3  t=new Test3();         System.out.println(t.name);         System.out.println(t.xueli);           //建立对象         Test3  ss=new Test3("liwenjie","232");         System.out.println(ss.name);         System.out.println(ss.xueli);     } }

【总结】也就是说在一个类中，经过构造方法来建立对象，经过建立对象来调用构造方法，一个类中能够有多个构造方法，方法名相同，参数列表不一样，能够经过不一样的参数列表调用不一样的构造方法。

2若是一个类中只有一个有参的构造的方法，那么咱们还想经过无参的构造方法来建立对象，那么jvm也就不提供了。若是咱们必定要用无参的构造方法来建立对象，那么就须要咱们手动提供一个无参数的构造方法。

• This关键字

1. 使用this关键字的前提条件:

• This关键字只能出如今没有被static关键字修饰的方法中。

1. This关键字的做用：

• This 关键字表示对当前类某个对象的引用，那个对象调用当前的成员方法，this关键就表明那个对象。

1. This关键字的第一种用法:

• 当方法中的局部变量或者参数和成员属性彻底一致时，程序默认采用就近原则，若是想要输出成员变量的值，就可使用this.属性名的方式来调用。

1. This关键字的第二种用法:

• 当this关键字以this(参数列表)的形式出如今构造方法的第一句代码时，就表示当前的构造方法调用了该类中其余的构造方法。根据参数列表匹配。

This关键字的第一种用法示例: public class Test4 {     String  name="张三";       public  void display(){        String  name="李四";         System.out.println(name);//李四，程序默认采用就近原则输出李四，         System.out.println(this.name);// 张三     } public static void main(String[] args) {         Test4   t=new Test4();         t.name="liwenjie";         t.display();     } } public class Test4 {     String  name="张三";       public  void display(){         String  name="李四";         System.out.println(this.name);     }     public Test4(String  name){         //若是这样写jvm分不清楚到底那个是成员属性，那个是局部属性，         //若是加上this.属性名的方式，它就表明了调用的必定是当前类成员属性的值。        //name=name;         this.name=name;     }     public static void main(String[] args) {         Test4   t=new Test4("天水市");         t.display();     } }   【总结】当成员变量名和方法中的局部变量彻底一致时，程序默认采用就近原则，若是想要输出成员变量的值，那么就使用this.属性名的方式就能够输出成员变量的值。This关键字就表明当前类的那个对象，输出的值必定是成员属性的值。

 

This关键字第二种用法的示例:  public class Test5 {     String name;     int age;       public Test5(){         this("zhangsan",23);         System.out.println("无参数的构造方法");     }     public  Test5(String name,int age){          this.name=name;          this.age=age;         System.out.println("有参数的构造方法");      }       public static void main(String[] args) {         //建立当前类的对象         Test5 t=new Test5();         System.out.println(t.name);         System.out.println(t.age);       } } 【总结】当this关键字以this(参数列表)的形式出如今构造方法的第一句代码时，就表示了当前的构造方法调用了该类中其余的构造方法。根据参数列表匹配。

• JavaBean

JavaBean是java语言编写类的一种标准规范，javaBean也是一个类，只不过符合javaBean定义规范的类称为javaBean。

定义javaBean的规范

1. 提供一个公共无参的构造方法。
2. 全部的成员属性必须是Private修饰的。
3. 为全部的成员属性提供公共的set，get方法。

1. Set 方法:是无返回值有参数的，经过set方法给私有的属性设置值，Set方法的命名规则是SetXxx, 其中Xxx是属性名，并且属性的首字母大写 例如:setName();
2. Get 方法: 是有返回值无参数的，经过Get方法来获得私有属性的值，get方法的命名规则是GetXxx,其中Xxx是属性名，并且属性的首字母大写 例如:getName();

//定义JavaBean规范 public class Test6{     //成员变量必须是Private修饰    private  String stuname;    private String stuaddre;    private String stuXueli;    private Integer  stuAge;    //提供一个公共无参的构造方法     public Test6(){       }    //获得属性的值     public String getStuname() {         return stuname;     }   //设置属性的值     public void setStuname(String stuname) {         this.stuname=stuname;     }       public String getStuaddre() {         return stuaddre;     }       public void setStuaddre(String stuaddre) {         this.stuaddre = stuaddre;     }       public String getStuXueli() {         return stuXueli;     }       public void setStuXueli(String stuXueli) {         this.stuXueli = stuXueli;     }       public Integer getStuAge() {         return stuAge;     }       public void setStuAge(Integer stuAge) {         this.stuAge = stuAge;     } } public class Test7 {     public static void main(String[] args) {         //建立对象         Test6 t=new Test6();         t.setStuname("wangzhiya");         t.setStuaddre("山西省");         t.setStuXueli("本科");         t.setStuAge(20);         System.out.println(t.getStuname());         System.out.println(t.getStuaddre());         System.out.println(t.getStuXueli());         System.out.println(t.getStuAge());     } }