java重点——面向对象--构造方法、this关键字、JavaBean

Bertha 。 2022-12-01 15:39 251阅读 0赞

# 1、构造方法 #

●对象怎么来的？对象是通过构造方法创建出来的。  
构造方法的定义语法：

访问修饰符 类名(参数列表){
         
     
    }
    //访问修饰符 public

●构造方法的方法名称必须和类名相同  
●构造方法中没有 return 也没有返回值和 void  
●构造方法不能被 static 等关键字修饰

构造方法有两个作用：  
1.创建对象  
2.通过构造方法可以对成员变量(属性)进行初始化

●一个类中，可以存在多个构造方法，只要构造方法之间的参数列表(个数、类型、顺序的 不同)不同即可  
●构造方法也可以重载

### 构造方法分类 ###

构造方法分为:  
1.无参数的构造方法  
2.有参数的构造方法

其中无参构造又包括：  
1.显示无参数的构造方法（用户自定义的）  
2. 隐式无参数的构造方法 ：当一个类中，不存在任何形式的构造方法的时候，JVM 会默认提供一个无 参数的构造方法。

【当一个类中存在了一个或多个任何形式的构造方法了，那么 JVM 就不会再 提供这个隐式的无参数的构造方法了。】

当一个类中如果存在有参数的构造方法，那么此时还想通过无参数的构造方法 来创建对象，那么只需要添加一个无参数的构造方法即可。

package com.bdit; 
    /* 
    构造方法的定义  
    */ 
    public class Test3 {
         
     
        String name;     
        int age; 
     
        //无参数的构造方法     
        public Test3(){
                 
        	//给成员属性进行初始化         
        	name="小明";         
        	age=22;         
        	System.out.println("构造方法");     
        } 
         public Test3(String n,int a){
                 
         	//把参数赋值给成员属性 name 和 age         
         	name=n;         
         	age=a;         
         	System.out.println("有参数的构造方法"+n+"  "+a);     
         } 
         public static void main(String[] args) {
                 
         	//创建对象         
         	Test3 t1=new Test3();         
         	//直接输出成员属性         
         	System.out.println(t1.name+" "+t1.age); 
     
            //用有参数的构造方法创建对象         
            Test3 t2=new Test3("小红",18);         
            //输出成员属性         
            System.out.println("name="+t2.name);         
            System.out.println("age="+t2.age); 
     
        } 
     
     
    }

package com.bdit; 
    /* 
    通过 JVM 提供的隐式构造方法来创建对象  
    */ 
    public class Test4 {
         
     
        public static void main(String[] args) {
                 
        	//创建对象         
        	Test4 t=new Test4();         
        	t.test();     
        } 
     
        public void test(){
                 
        System.out.println("测试");     
        } 
    }

### 练习题 ###

封装一个学生(Student)类：  
学生应该有姓名(name)、年龄(age)、性别(gender)，班级号(classNum)，座位号(sno)。  
提供一个有参数的构造化方法以便能很方便的创建一个学生对象。  
提供一个方法(displayInfo())用来显示这个学生的姓名、年龄、性别、所在的班级和他的 座位号。  
写一个 main 方法创建两个学生对象，分别调用 displayInfo()方法显示各自的信息。

package com.exercise; 
    	 public class Student {
             
    	 	//姓名     
    	 	String name;     
    	 	//年龄     
    	 	int age;     
    	 	//性别 
    	 	String gender;     
    	 	//班级号     
    	 	String classNum;     
    	 	//座位号     
    	 	int sno; 
     
        public Student(String n,int a,String g,String c,int s){
                 
        	name=n;         
        	age=age;         
        	gender=g;         
        	classNum=c;         
        	sno=s;     
        } 
         public void displayInfo(){
                 
         	System.out.println(" 姓名:"+name+" 年龄:"+age+" 性别:"+gender+" 班 级:"+classNum+" 座位:"+sno);     
         } 
         
          public static void main(String[] args) {
                 
          		Student stu1=new Student("小明",20,"man","java01",1001);         
          		stu1.displayInfo(); 
     
            	Student stu2=new Student("小红",21,"women","java02",1002);         
            	stu2.displayInfo();     
           } 
     }

# 2、this关键字 #

使用 this 关键字的前提条件：  
this 关键字只能用在没有被 static 关键字修饰的方法中

this 关键字的作用：  
this 关键字表示对当前类某个对象的引用，哪个对象呢？哪个对象调用该方法，该 方法中的 this 关键字就指向哪个对象。

this 关键字的第一种用法：  
当方法中参数名或方法中局部变量和成员变量完全一致时，可以通过 this 关键字来 区分成员属性。  
语法：this.属性名

当方法中的局部变量或参数同成员变量完全一致时，以局部变量或参数为主(就近原则)

package com.bdit; 
    /* 
    this 关键字 区分参数和变量的作用域  
    */ 
    public class Test5 {
         
     
        int num=100; 
     
        public void display(){
                 
        	//当方法中的局部变量和成员变量完全一致时，直接输出变量时，JVM 会采用就 近原则进行输出         
        	int num=200;         
        	System.out.println(num);//200 
     
            System.out.println("成员属性 num"+this.num); 
        } 
     
      	public void display2(int num){
                 
      		this.num=num;//对象名.num=num;         
      		System.out.println(num);     
      	} 
     
        public static void main(String[] args) {
                 
        	Test5 t=new Test5();         
        	t.display();         
        	//System.out.println("-------------->"+t.num);     
        } 
    }

this 关键字的第二种用法：  
当 this 以 this(参数列表)的形式出现在构造方法的第一句代码时，就表示当前构造 方法调用了该类中其它的构造方法，通过参数进行匹配。

package com.bdit; 
     
    /**  
    * this 关键字调用构造方法  
    * */ 
    public class Test6 {
         
    	public Test6(){
                 
    		System.out.println("无参数的构造方法");     
    	} 
     
        public Test6(int n1,int n2){
                 
        	System.out.println("两个 int 类型的构造方法"+n1+"  "+n2);     
        } 
     
        public Test6(String content){
                 
        	this();         
        	System.out.println("一个 String 类型的构造方法"+content); 
     
        } 
     
      	public static void main(String[] args) {
                 
      		Test6 t1=new Test6("hello");     
      	} 
     
    }

# 3、JavaBean #

JavaBean 是 Java 语言中一种标准的类的定义方式。凡是符合 JavaBean 的定义规范都统称为 JavaBean，但是 JavaBean 也是一个类。

JavaBean 的定义规范：  
●成员属性使用 private 关键字来修饰，语法:private 数据类型 属性名;  
● 提供一个公共(public)无参数的构造方法  
●为所有的私有属性，提供 public 修饰的 set 和 get 方法。

set 方法是无返回值有参数的方法，目的是给成员属性赋值。  
set 方法名的命名规则：  
public void setXxx(数据类型 参数名)，说明 Xxx 是相应的属性名，而且属性名的首 字母大写。

get 方法是有返回值无参数的方法，目的是获取私有属性的值，  
get 方法的命名规则：  
public 返回值 getXxx()，Xxx 是属性名，首字母大写

### private访问修饰符 ###

private 表示私有的，修饰的属性，只能在当前类中被使用。

【类和类之间的方法或属性可以相互被调用，只需要创建一个目标类的对象即可】

package com.bdit; 
     
    public class Test7 {
         
     
        private String name="张三"; 
     
        public void display(){
                 
        	System.out.println(name);     
        } 
     
        public void setName(String name){
                 
        	this.name=name;     
        } 
     
        public String getName(){
         
         	return name;     
         } 
     
        public static void main(String[] args) {
                 
        	Test7 t=new Test7();         
        	t.display();     
        } 
    }

package com.bdit; 
     
    public class Test8 {
         
     
        public void method1(){
                 
        	//调用 Test7 类中的 display 方法，创建 Test7 的对象         
        	Test7 t1=new Test7();         
        	System.out.println(t1.getName());         
        	//t1.setName("小明");         
        	//t1.display();     } 
     
        public static void main(String[] args) {
                 
        	Test8 t=new Test8();         
        	t.method1();     
        } 
     
    }

### package创建包 ###

包(package)  
引入包的目的：为了管理大型软件系统中，数目众多的类，同时为了能够解决类名命名冲突 的问题，java 中引入了包的概念。

●包其实就是一种目录层次结构的体现  
●创建包的语法：package 包名;  
●包名可以是多级目录层次，层次之间用英文的点分割  
● 例如:package com.bdit; 其实在系统中的体现就是 com 文件夹中一个 bdit 文件 夹,bdit 文件夹中存放着文件。  
●包的声明一定是位于源代码的第一句代码。

带包的类：

package com.bdit; 
     
    public class Test1{
         
     
     	public static void main(String[]args){
         
     
      		System.out.println("HelloWorld");  
      	} 
    }

### import导包 ###

为什么要导包？当两个类不在同一个包下，如果想要能够在当前类中使用目标类，那么就必 须在当前类中导入目标类所在的包。

导包的语法：  
import 包名.类名; 或者 import 包名.\*;  
\*表示包下所有的类。  
【import 导包一定要位于 package 的下面】

### 一个 java 源文件中存在多个类 ###

【一个 Java 源文件中，可以存在多个类，但是只能有一个类带 public 访问修饰符，而且 main 方法就要位于该类中，而且 java 源文件的名称还要和带 public 修饰的类类名相同，其它类 都要位于每个类结束大括号的外面，而且不需要添加 public 访问修饰符。】