JAVA零学习之基础归纳（六）--类与对象、抽象、封装、构造方法、 this 关键字

JAVA的基础学习归纳之基础面对对象

从零开始学习java，一天进步一点点，一天学习一点点，多掌握知识和多多做题，本篇主要写java的基本语法和面向对象的基础内容

1、面对对象的编程思想

1.1面对过程的编程思想

• 面对过程的编程思想，是以流程(过程)为单位，更注意最后功能的实现

1.2面对对象的编程思想

• 面对对象的编程依赖于面对过程的编程
• 面对对象的编程思想，就是把一个事物看成一个整体，从事物的特征(属性)和行为(功能、方法)两个方面进行描述。
• 面对对象是一种程序设计的思想，在面对对象的指引下，使用Java语言去设计、开发计算机程序，而这里的对象是泛指一切的事物，每个事物都有自己的属性和行为，而面对对象的思想就是，通过对象，将事物的属性和行为表达出来。
• 万物皆可对象
• 举例
  • 面向过程：把衣服脱下来->放到洗衣机->放点洗衣粉->加点水->浸泡 10 分钟->开动洗衣 机->甩干->晾起来
  • 面向对象：把衣服脱下来->打开全自动洗衣机->放衣服->启动->晾起来
• 区别：
  • 面向过程：重点是步骤
  • 面向对象：重点是对象，对象是洗衣机
• 特点：
  • 将复杂的问题便简单化，并将我们从执行者转换成指挥者
• 面向对象的编程中一定会用到面向过程的编程
• 面向对象包含了三大特征：封装、继承、多态（四大特征：封装、继承、多态、抽象）

1.3 什么是对象

• 对象：
  • 在生活中存在的一个事物，就可以为一个对象
  • 万事万物，皆可对象
• 对象特点：
  • 无论两个事物多么相似、接近，而这永远都是两个对象
  • 一项法律、法规都是一个对象

1.4 抽象

• 所谓抽象，就是把同一类事物中具有相同的特征(属性)和行为(功能、方法)所提取出来进行归纳总结。

1.5 封装

• 封装：是将抽象出来的数据进行包装。
• 封装目的：加强保证数据的安全
• 封装包括两个方面：属性和方法
• 封装不是绝对的封装，如果想要访问封装的数据，通过其指定的入口即可访问
• 抽象和封装这两个特征，在程序中具体表现形式就是【类】
• 属性和方法的封装两者是相辅相成密不可分的

1.6 类

1.6.1 什么是类

• 类：是一组相关属性和行为的集合，也可以看成是属性和行为的模板，使用事物的属性和行为来秒速这个类。
  • 例如：具有小汽车模型的图片可以成为类，而小汽车的颜色、几个轮子、多大排放量、等等都是属性(成员属性)，小汽车会跑，而这个跑则是行为(成员方法)。
• 现实中：秒速一类的事物
  • 属性：是该事物所具有的状态信息
  • 行为：是该事物能够做什么
• 例如：
  • 人类（类）
    • 属性：名字、体重、身高、年龄等等
    • 行为：吃饭、说话、睡觉等等

2、类的定义

2.1 Java中用class关键字来描述类

• 类中：
  • 成员属性(变量)对应的是事物的特征
  • 成员方法：是对事物行为的描述
• 类定义语法：

public class 类名{ 
	//成员变量   
	//成员方法 
} 2.2 定义类

2.2定义类

• 定义类：就是定义类中的成员属性和成员行为(成员变量、成员方法)
• 成员变量：和之前定义变量形式几乎一样，但位置发生变化，成员变量位于类中
• 成员方法：和之前定义变量形式几乎一样，仅仅去掉static关键字
• 示例：

package com.bdit.text;

public class MethodTest {
//成员变量（成员属性）
    //姓名
     String name;
    // 年龄
     int age;
    // 性别
    String gender;
    
//成员方法（成员行为）    
    public  void speak(){
        System.out.println("说话");
    }
    public void run(){
        System.out.println("行走");
    }
    public void eat(){
        System.out.println("吃饭");
    }

}

2.3变量的分类

2.3.1 根据数据类型划分

• 基本数据类型变量
• 引用数据类型变量

2.3.2 根据位置划分

• 局部变量：定义在方法的内部或某个语句块的内部，局部变量只限于在定义的方法内或者语句块内使用
• 局部变量必须初始化后才能使用
• 全局(成员)变量：定义在类的内部。任何方法的外面，使用范围是整个类

2.4 类和对象

• 类和对象之间存在的关系：
  • 类是对对象的抽象
  • 对象是类的实例化

3、 如何创建对象

3.1语法

• 类名 对象名=new 类名()；

3.2 对象的使用

• 调用成员变量语法格式：对象名.成员属性(变量)
• 调用成员方法语法格式：对象名.方法名(参数列表)
• 成员属性都有默认值，所以在声明成员属性时，可以不用初始化，就可以使用

数据类型	默认值
byte	0
short	0
int	0
long	0
float	0.0
double	0.0
boolean	false
char	空字符
引用类型	null

• 示例：

package com.bdit.text;

public class Person {
//成员变量（成员属性）
    //姓名
     String name;
    // 年龄
     int age;
    // 性别
    String gender;

//成员方法（成员行为）
    public void speak(){
        System.out.println("说话");
    }
    public void run(){
        System.out.println("行走");
    }
    public void eat(){
        System.out.println("吃饭");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
//调用成员变量并且赋值
        person1.name="zhangsan";
        person1.age=25;
        System.out.println("姓名"+person1.name);
        System.out.println("年龄"+person1.age);
//调用成员变量看其默认值
        System.out.println(person1.gender);
//调用成员方法
        person1.speak();
        person1.run();
        person1.eat();
    }

}

4 成员方法的应用

4.1定义

访问修饰符 返回值类型 方法名称(参数列表){ 
 
} 

• 访问修饰符： public
• 返回值类型由返回值决定
• 成员属性可以直接在成员方法中使用，但main方法中如果由要调用成员属性和方法必须通过对象。属性名/方法名(参数列表)来调用
• 成员方法之间调用，直接写方法名(参数列表)即可

package com.bdit.text;

public class Person {
    
//成员方法（成员行为）
    public  void speak(String str){
        System.out.println("说话"+str);
    }
    public void run(){
        speak("aaaa");
        System.out.println("行走");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        person1.speak("mkm");
        person1.run();

    }

}

5、代码执行的顺序

5.1 代码从main方法开始也一定从main方法结束

/* 代码执行的顺序  */ 
public class Test2 { 
	public static void main(String[] args) {         
	//创建对象         
	Test2 t1=new Test2();         
	t1.method1();         
	System.out.println("method1 执行完毕");         
	System.out.println("程序结束");     
} 
 
	public void method1(){         
	System.out.println("====方法一========");         
	System.out.println("方法 method1 开始调用 method2");         
	method2(); 
	System.out.println("method1 调用 method2 结束");     
} 
 
	public void method2(){         
	System.out.println("=========方法二===========");         
	int n=method3()
	System.out.println("在 method2 输出 n 的值"+n);  
    System.out.println("method2 方法执行完毕");     
} 
 
    public int method3(){         
    System.out.println("=======方法三=========");         
    return 15;    
    } 
} 

6、构造方法

6.1 定义语句

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

访问修饰符 public

• 构造方法的方法名称必须和类名一致
• 构造方法中没有return也没有返回值和void
• 构造方法不能被static等关键字修饰
• 构造方法有两个作用：
  • 创建对象
  • 通过构造方法可以对成员变量(属性)进行初始化
• 一个类中，可有存在多个构造方法只要构造方法之间的参数列表(个数、类型、顺序的 不同)不同即可
• 构造方法也可以重载

6.2 构造方法分类

• 构造方法分为：
  • 无参数(默认)的构造方法
    • 显示无参数的构造方法
    • 隐式无参数构造方法
      • 当一个类中不存在任何形式的构造方法的时候，JVM会默认提供一个无参数的构造方法
    • 【当一个类中存在了一个或多个任何形式的构造方法了，那么 JVM 就不会再 提供这个隐式的无参数的构造方法了。】
    • 当一个类中如果存在有参数的构造方法，那么此时还想通过无参数的构造方法 来创建对象，那么只需要添加一个无参数的构造方法即可。

 /* 构造方法的定义  */ 
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); 
 
    } 
 
 
} 

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

7、练习

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

package com.bdit.text;

public class Student {
    String name;
    int age;
    String gender;
    int classNum;
    int sno;
    public Student(String n,int a,String g,int classNum,int sno){
        name=n;
        age=a;
        gender=g;
        this.classNum=classNum;
        this.sno=sno;

    }
    public void displayInfo(){
        System.out.println("姓名："+name+" 年龄："+age+" 性别："+gender+" 班级："+classNum+" 位次："+sno);
    }
 /*   public void disp(String name,int age,String gender,int classNum,int sno){
        System.out.println("姓名："+name+" 年龄："+age+" 性别："+gender+" 班级："+classNum+" 位次："+sno);
    }
*/

    public static void main(String[] args) {
        Student student01 = new Student("zhansgan",10,"nan",2,2);
        student01.displayInfo();


        Student student02 = new Student("lisi",25,"nv",1,1);
        student02.displayInfo();

  //      student02.disp("wangwu",24,"nan",1,2);



    }
}

8、this关键字

8.1 前提条件

• this关键字只能在没有被static关键字修饰的方法中

8.2 作用

• this关键字表示对当前类的某个对象的引用，，哪个对象呢？哪个对象调用该方法，该 方法中的 this 关键字就指向哪个对象。
• this的用法：
  • 当方法中参数名或者方法中局部变量和全局变量一致时，可以区分全局变量和局部变量
  • 必须放在构造方法的第一句语句(以this.(参数))，具有调用方法的作用

package com.bdit.text;

public class This01 {
    //this变量作用
//    1、区分局部变量和全局变量
    int a =900;

    public void text(){
        int a =100;
        System.out.println("text()中没有被this定义："+a);
        System.out.println("text()中被this.a定义："+this.a+" text()中没有被this定义："+a);
    }

    public static void main(String[] args) {
        This01 thiss = new This01();
        thiss.text();

    }
}

package com.bdit.text;

public class This02 {
  //this第二种用法
//     2、只能在构造方法中
    public This02(String name){

        System.out.println("--");
    }
    public This02(String name,int age){
        System.out.println("姓名："+name+" 年龄:"+age);
    }
    public This02(){
        this("q");
        this("a",6);//必须是构造方法的第一个语句
        System.out.println("wucan");
    }

    public static void main(String[] args) {
        This02 this02 =new This02();
    }
}

9、JavaBean

9.1 JavaBean也是一个类

• JavaBean是Java语言的一种标准定义类的方式，凡是符合JavaBean的定义方式，都可以是JavaBean

9.2 定义规范

• 成员变量使用private来修饰，语法:private 数据类型 属性名;

• 提供一个（public）无参的构造方法

• 为所有私有属性，提供set和get方法

• set方法是：无返回值但有参数的方法。目的是：给私有属性赋值

  • 命名规则：

  public void setXxx(数据类型  参数名){
  	this.属性名=参数名
  }
  

• get方法是：有返回值但无参数的方法。目的是：给获得私有属性的值

  • 命名规则

  public 数据类型 get参数() {    
  	return 参数;
  }
  
  

• 示例：

package com.bdit.ches;

public class Test {
}
class Dept {
    private int deptId;
    private String deptName;

    public int getDeptId() {
        return deptId;
    }

    public void setDeptId(int deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
}

10、private访问修饰类

10.1 private类、

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

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

  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();   
    } 
  

  }

11、 package 创建包

11.1 packge（包）

• 引入包的目的：为了管理大型软件系统中，数目众多的类，同时为了能够解决类名命名冲突 的问题，java 中引入了包的概念。
• 包其实就是一种目录层次结构的体现

11.2 创建包

• 语法：package 包名；
  • 包名是可以多层次的但其中用英文点来分割
• 声明：包的声明是在代码的第一行

带包的类

package com.bdit; 

public class Test1{ 

 public static void main(String[]args){ 

  System.out.println("HelloWorld");  
	  } 
  } 

• 带包的编译语法
  • javac -d . 类名.java
    • 点的意思表示当前类生成的带包的字节码文件位于当前目录
• 运行带包的字节码文件：
• java 包名.类名
• 包名.类名又称为类的全限定名

12、 import导包

• 为什么要导包？当两个类不在同一个包下，如果想要能够在当前类中使用目标类，那么就必 须在当前类中导入目标类所在的包。
• 导包的语法： import 包名.类名; 或者 import 包名.*; *表示包下所有的类。
• 【import 导包一定要位于 package 的下面】

13、 一个Java源文件中存在多个类

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

14.总结

本篇大部分为应用，不要死记硬背，因为如果死记硬背算记住在应用上也是很生涩的，并没有那种依靠自己理解来记住用的方便，而基础的问题一定要掌握，基础打好等到后面难的也会变简单。