JAVA基础第六天

面向对象编程(上)

1.面向过程和面向对象的编程思想 

• 面向过程的编程思想：
  • 以流程为为单位，注重功能的实现
• 存在的问题：
  • 流程之间相互依赖，导致代码之间的耦合性非常高
  • 不利于程序的维护和后期功能的扩展
• 面向对象的编程思想： 
  • 面向对象是建立在面向过程的基础之上，也就是说在面向对象的编程中一定会用到面向过程的编程思想。
  • 面向对象就是把任何一个事物看作是一个整体，从事物的特征 ( 属性 ) 和行为 ( 方法、功能 )两个方面进行描述。
• 面向对象特点： 
  • 能够以更加贴合实际情况或者正常的思维方式，来去理解一个事物或者软件的功能
  • 面向对象是来源于生活服务于生活
  • 面向对象的编程英文简称 --OOP
  • 面向对象的四大或者三大特征：抽象 ( 可选 ) 、封装、继承、多态
• 面向对象和面向过程的思想对比： 
  • 面向过程：是⼀种以过程为中心的编程思想，实现功能的每⼀步，都是自己实现的
  • 面向对象：是⼀种以对象为中⼼的编程思想，通过指挥对象实现具体的功能

---

 对象

1.什么是对象？

对象：对象是指具体存在的一个事物就是一个对象，在Java中万事万物皆对象

特点：

• 无论两个事物有多么的相近或者相似，永远都是两个不同的对象。
• 一项法律、法规、规章制度、政策都是一个对象

---

2.对象的创建和使用

1.类是模板，可以通过类创建N个属于这个类的事物就是对象，基于这个类创建的对象，那么这个对象就拥有类中定义的所有属性和方法，一个类中可以创建出N个对象，但是你要通过new关键字，那么创建的对象就是一个新的对象

• 创建对象的格式：
  • 类名 对象名 = new 类名();
• 调用成员的格式： 
  • 对象名.成员变量
  • 对象名.成员方法();

示例代码：

public class Test {
    public static void main(String[]args){
            //创建对象  类名 对象名 = new 类名();
        Test1  test1 = new Test1();
        //对象名.变量名
        System.out.println(test1.name);//null
        System.out.println(test1.age);//  0
        //对象名.方法名
        test1.display();
}    
}
//我们先创建一个类
public class Test1{
        创建一个方法
    public void display(){
        System.out.println("张三");
            }
   
    
}

---

3.单个对象的内存图 

---

抽象

抽象就是把同一类事物，它们共同的特征 ( 属性 ) 和行为 ( 方法 ) 进行抽取、归纳、总结。

封装

• 意义和目的：就是包装的意思，为了保证抽象出来数据的安全性
• 封装包括对属性和方法的封装，而且同一类事物要把它们的属性和方法封装到一起，这才是一个完整的封装
• 封装不是绝对的，如果需要访问封装起来的属性和方法，就必须通过指定的公共入口(方法、接口)。
• 抽象和封装都是概念性的，在程序中它们都需要代码的形式来体现，这就是类 (class)

1.private关键字

概述：private是一个修饰符，可以用来修饰成员(成员变量，成员方法)。

特点：被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用， 提供相应的操作

• 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
• 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

示例代码:

/*定义标准的学⽣类，要求name和age使⽤private修饰
并提供set和get⽅法以及便于显示数据的show⽅法
测试类中创建对象并使⽤，最终控制台输出 林⻘霞，30**/


/*
 学⽣类
*/
class Student {
 //成员变量
 private String name;
 private int age;
 //get/set⽅法
 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 show() {
 System.out.println(name + "," + age);
 }
}
/*
 学⽣测试类
*/
public class StudentDemo {
 public static void main(String[] args) {
 //创建对象
 Student s = new Student();
 //使⽤set⽅法给成员变量赋值
 s.setName("林⻘霞");
 s.setAge(30);
s.show();
 //使⽤get⽅法获取成员变量的值
 System.out.println(s.getName() + "---" + s.getAge());
 System.out.println(s.getName() + "," + s.getAge());
 }
}

---

类

在Java中，类中存放的就是抽象出来的属性和方法。

类的定义语法：

[访问修饰符] class 类名{ 

//属性 //方法 

    }

属性：就是变量，也成为属性。

• 成员属性或者全局变量：就是在类中任何方法或者代码块外部定义的变量，整个类中都可以使用。成员变量，都有默认值，会根据数据类型来决定。
  • 整数类型的默认值是 0
  • 浮点类型的默认值是 0.0
  • boolean 类型的默认值是： false
  • char 类型的默认值是空格
  • 所有引用类型的默认值都是 null
• 局部属性或者局部变量：就是在方法或者代码块内部定义的变量，只能在方法内部或者代码块内部使用，而且局部变量必须要初始化了才能使用。

---

构造方法

创建类的对象时，实际上是通过构造方法来完成的

构造方法：

• 方法名和类名相同
• 没有 void ，也没有 return
• 方法不能被 static 修饰

类名 对象名 =new 构造方法 ( 参数列表 );

语法：

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

 }

构造方法的作用:

• 创建对象
• 可以对成员属性进行初始化

---

构造方法的分类：

• 当一个类中，不存在任何形式的构造方法时，那么JVM会提供一个默认的无参数的构造方法。
• 构造方法分为：
  • 无参数的构造方法
    • 隐式无参数的构造方法
    • 显示无参数的构造方法
  • 有参数的构造方法，在调用时，需要传递数据，而且数据要和构造方法中参数的类型，个数，顺序必须完全匹配。
• 构造方法中的参数，有被称为形式参数(形参)，在调用这个构造方法时，传递的数据称为实际参数(实参)
• 在一个类中，可以同时拥有多个构造方法，只要构造方法之间的参数列表不同即可。

示例代码:

/** 构造方法 */
public class Demo2{ 
    public Demo2(){ 
             System.out.println("------无参数的构造方法------"); }
    public Demo2(String name,int age){
             System.out.println("------有参数的构造方法----- name="+name+", age="+age); }
    public Demo2(int a,int b){ 
             System.out.println("------有参数的构造方法----- a="+a+", b="+b); }
    public static void main(String[]args){ 
             Demo2 demo2=new Demo2("zhangsan",20); 
             

                } }

---

方法

方法就是完成同一功能的代码块。

语法：

[访问修饰符] 返回值类型 方法名(参数列表){ 
    //返回值 
    return 返回值; 
}

• 方法分类：

1.无返回值无参数的方法

[访问修饰符] 返回值类型 方法名(参数列表){
 //返回值 
return 返回值; }

---

2.有返回值无参数的方法

[访问修饰符] 返回值类型 方法名(){
 //代码
 //返回值 return 值; 
}
说明：返回值类型由返回值来决定的 
      带有返回值的方法的最后一句代码，一定是：return 返回值; 而且一次只能返回一个值。

---

3.无返回值有参数的方法

[访问修饰符] void 方法名(数据类型 参数1,数据类型 参数2,...){

 }
说明： 方法中的参数可以有多个，参数之间使用逗号分隔。
      方法中的参数也称为形式参数(形参)
      调用有参数的方法时，传递的数据称为实际参数(实参)，在传递数据时，
      必须和目标方法中参数 的个数，类型，顺序完全一致。

4.有返回值有参数的方法

[访问修饰符] 返回值类型 方法名(参数列表){ 
//最后一句代码
 return 返回值; }

示例代码：

/** 方法的定义 */
public class Demo3{ 
    //无返回值无参数的方法
     public void test1(){ 
        System.out.println("------无返回值无参数的方法------"); }
    //有返回值无参数的方法 
    public int test2(){ 
        System.out.println("------有返回值无参数的方法------");
         return 10+20; }
    //无返回值有参数的方法 
    public void test3(int a,int b,int c){ 
        System.out.println("a+b+c= "+(a+b+c)); }
    //有返回值有参数的方法 
public String test4(String name,int age,String address){ 
    return "姓名:"+name+",年龄是:"+age+",住址是:"+address; }
public static void main(String[]args){ 
    //创建对象 
    Demo3 demo3=new Demo3(); 
    //调用方法 
        demo3.test1();
     int num=demo3.test2(); 
    System.out.println(num); 
    System.out.println(demo3.test2());
     demo3.test3(10,20,30); 
    System.out.println(demo3.test4("张三",25,"天津")); } }

---

代码的执行顺序

• 在JavaSE中，main方法是程序的入口，所有普通的方法，都要在main方法中被调用才有机会得到运行；普通方法运行完毕后，再回到Main方法，所以，程序从Main方法开始，也从Main方法结束。
• 普通方法之间的调用，直接写 方法名(参数列表) 即可

示例代码：

/** 代码之间执行的流程 */
public class Demo5{ 
public static void main(String[]args){ 
Demo5 demo5=new Demo5(); 
demo5.t1(); 
demo5.t2(50,55);
System.out.println("---程序结束---"); }
public void t1(){ 
System.out.println("---开始执行t1方法......");
System.out.println("---t1方法执行完毕---"); }
public void t2(int a,int b){ 
System.out.println("---开始执行t2方法......"); 
System.out.println(a+"+"+b+"="+(a+b));
System.out.println("---t2方法执行完毕---"); 

} }

---

this关键字

• 使用场景：this关键字只能出现在没有被static修饰的方法中。
• 作用：this关键字表示对当前类某个对象的引用（哪个对象调用这个方法，this就指向谁）
• 用法：

  • 当方法中的局部变量或者参数和成员(全局)变量完全一致时，以局部变量或者参数为主(就近原则);如果此时就想调用全局变量，则可以通过this关键字来解决，格式是：this.属性名
  • 当this以this(参数列表)的形式，出现在构造方法的第一句代码时，就表示当前构造方法，调用了该类中其它的构造方法，可以通过this的参数列表来匹配。

示例代码：

/** 就近原则 */
public class Demo6{ 
int num=999;
 public Demo6(){
 this("张三",22); 
System.out.println("---------回到了无参数的构造方法--------"); }
public Demo6(String name,int age){ 
System.out.println("有参数的构造方法 name="+name+",age="+age); }
public static void main(String[]args){ 
Demo6 demo6=new Demo6();
 demo6.t1(); }
public void t1(){ 
int num=666; 
System.out.println(this.num);//对象名.属性名 调用的一定是全局变量 } }

---

方法重载

• 多态：就是同一种事物在不同的情况下有多种表现形式。
• 多态有两种表现形式
  • 方法重载
  • 方法重写
• 方法重载：方法重载：在同一个类中，有多个方法名相同，但是参数列表不同包括参数的个数、类型、顺序的不同。
  • JVM会根据参数来匹配相应的方法
  • 在Java中普通方法和构造方法都可以重载
• 返回值类型不同，其它都相同的情况下，构不成方法重载。

/** 方法重载 */
public class Demo7{ 
public static void main(String[]args){ 
Demo7 demo7=new Demo7(); 
demo7.t1(100); 
demo7.t1(20,"zhangsan"); }
public int t1(int a){ 
return 100; }
public double t1(int a,int b,int c){ 
return 99.99; }
public void t1(){ 
System.out.println("---无参数的t1方法---"); }
public void t1(int a,int b){
 System.out.println("两个参数："+(a+b)); }
public void t1(String name,int age){ 
System.out.println("姓名:"+name+" 年龄:"+age); }
public void t1(int age,String name){ 
System.out.println("年龄:"+age+"，姓名:"+name); 

} }

---

Object类

• Object类在Java中，是所有类的父类（超类、基类、根类），它位于java.lang包中。
• 凡是位于java.lang包中的类，都无需导包，可以直接使用。
• 如果一个类没有明确指明它的父类，则父类默认就是Object类。
• Object类中的方法：
  • public String toString()：用来输出对象的字符串表示形式，包名 . 类名 @对象哈希码值的16进制

---

包

• 为了解决在大型项目开发中，数目众多的类命名冲突的问题，java引入了包的概念。包其实就是我们操作系统中的目录。
• 包的目录层次结构使用.分隔

---

package打包

• 语法：
  • package 包名 ;
  • package 一定要位于源文件的第一句代码
• JDK8之前编译带包的类语法：
  • javac -d . 类名.java
  • . 表示在当前目录生成带包的字节码文件
• 在指定目录下生成带包的字节码文件
  • javac -d 目录 类名 .java
• JDK8之前执行带包的字节码文件：
  • java 包名 . 类名

import导包

• 如果使用的目标类，和当前类不在同一个包下，则必须导入目标类所在的包，才能使用。
• 导包语法：
  • import 包名 . 类名 或者 包名 .* ；
  • Import 语句一定要位于 package 语句下面。

---

JavaBean

• JavaBean是一个可以重复使用的组件，也是Java中的一个普通类，只不过它需要遵循一定的规则，才能称为javabean
• JavaBean的规范：
  • 类中所有的成员属性都是私有，也就是private来修饰
  • 提供一个公共无参数的构造方法
  • 为所有私有的属性提供公共的set和get方法。
  • set 方法是有参数无返回值的，目的是通过 set 方法给 javabean 中的私有属性赋值，命名
    方式 setXxx( 数据类型 参数名 ) ,Xxx 表示是属性名
  • get 方法是无参数有返回值的，目的是通过 get 方法获取 javabean 中私有属性的值，命名
    方式 getXxx()
  • boolean类型的get方法 是以 is开头的

示例代码：

/** javabean */
public class Demo9{
public static void main(String[]args){ 
Student stu=new Student();
 stu.setStuId(1001); 
 stu.setName("zhangsan"); 
 stu.setScore(99.9); 
 stu.setGender(false);
System.out.println(stu.getStuId()+" "+stu.getName()+" "+stu.getScore()+" "+stu.isGender());
}
 }
//学生类 
class Student{
 private int stuId; 
 private String name; 
 private double score;
 private boolean gender; 
 public Student(){
 }
public void setStuId(int stuId){ 
    this.stuId=stuId; }
public int getStuId(){
     return stuId; }
public void setName(String name){ 
    this.name=name; }
public String getName(){ 
    return name; }
public void setScore(double score){ 
    this.score=score; }
public double getScore(){ 
    return score; }
public void setGender(boolean gender){ 
    this.gender=gender; }
public boolean isGender(){ 
    return gender; } }

---

访问修饰符 

• 访问修饰符可以用来限定一个元素被使用的范围
• 【private只能修饰属性和方法，不能修饰类，一般成员属性私有，方法公共public】
• 【public一般用来修饰类和方法，默认修饰符也可以修饰属性、方法、类】
• 【protected比较特殊，一般用来修饰受保护的属性和方法】

---

方法的传递

• Java中参数的传递，无论是基本数据类型还是引用数据类型，都是采用的值传递
• 基本数据类型，传递的是参数的副本，目标方法中无论如何修改，都不影响其本身
• 引用数据类型，传递的是地址，目标方法中如果对其进行修改，其本身也会发生变化

基本数据类型传递：

/** 基本数据类型参数的传递 */
public class Demo12{ 
public static void main(String[]args){ 
Demo12 demo12=new Demo12(); 
int n=10; 
System.out.println("调用方法t1之前,n的值是:"+n);
 demo12.t1(n); 
System.out.println("调用方法t1之后，n的值是:"+n); }
public void t1(int num){ 
System.out.println("t1方法中参数Num="+num); 
num=999; 
System.out.println("t1参数重写赋值后Num="+num); } }

引用数据类型传递：

/** 引用类型参数的传递 */
public class Demo13{ 
public static void main(String[]args){ 
Demo13 demo13=new Demo13(); 
Animal animal=new Animal(); 
animal.name="Dog"; 
animal.age=5; 
System.out.println("调用t1方法之前："); 
animal.display(); 
demo13.t1(animal); 
System.out.println("调用t1方法之后:"); 
animal.display(); }
public void t1(Animal animal){ 
animal.name="Tiger"; 
animal.age=10; } }
class Animal{ 
String name; 
int age; 
public void display(){ 
System.out.println("动物类"+name+",年龄"+age); } }