1.面向过程的代表语言：C语言

面向过程：每一步都需要一步步实现，按照程序进行编程

2.面向对象

面向对象是基于面向过程的编程思想；

2.1面向对象：是以对象为基础的编程—分析需求，找到对象，利用对象去处理业务

2.2什么是对象？

  1.  万物皆对象--看得见摸得着的东西<br />（1）特征（属性）--名词<br />（2）特征（方法）--动词

2.3面向对象的特点

（1）高效—-节省代码量，可以进行封装，将一些共有的属性和方法进行打包
（2）可以将程序中的逻辑进行抽象—-把对象中的共有的属性进行提取—>封装

2.4面向对象的特征：封装、继承、多态

封装：实际上就是把一些共有的属性和方法进行抽象之后打包—-后面可以灵活地调用
继承：子类可以继承父类的属性和方法—还可以拓展父类的功能
多态：贯穿于整个oop的，灵活地比较难理解的点—一个对象多种状态

2.5我们学习Java中的最基本的单位（层级结构）—-类

类可以封装数据
类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现

2.6定义类其实就是定义类的成员(成员变量和成员方法)

成员变量：就是事物的属性
定义成员变量，在类中，方法外
成员方法：就是事物的行为
定义成员方法，就是一种方法，只不过不用static
调用类：创建一个对象
格式：类名 对象名=new 类名（）；
匿名对象：new 类名（）；只能调用一次。
调用成员变量：对象名.成员变量
调用成员方法：对象名.成员方法

案例:

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-23-10:44
  4.  */
  6. /**
  7.  * 需求：封装一个学生类
  8.  *
  9.  * 学生的事物：
  10.  * 特征：姓名，年龄····
  11.  * 行为：学习，吃饭····
  12.  *
  13.  * 成员变量（全局变量）：声明在类中，方法外
  14.  * 初始化：不必要
  15.  *
  16.  * 成员方法：其实就是方法，只不过不能加static
  17.  */
  18. public class Student {
  19.     //成员变量---属性
  20.     String name;
  21.     int age;
  23.     public void study(){
  24.         //成员方法---行为
  25.         System.out.println("good good study");
  26.     }
  27.     public void eat(){
  28.         System.out.println("干饭啦");
  29.     }
  30. }
  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-23-11:04
  4.  */
  6. /**
  7.  * Student 是一个类，用来描述学生的信息
  8.  * 利用demo这个类来实例化Student
  9.  *
  10.  * 对象的实例化---new 对象
  11.  * 格式：
  12.  *  类名 对象名=new 类名（）
  13.  *
  14.  *  访问对象的属性
  15.  *  成员变量：对象名.成员变量
  16.  *  成员方法：对象名.成员方法
  17.  */
  18. public class StudentDemo {
  19.     public static void main(String[] args) {
  20.         //实例化对象
  21.         Student s=new Student();
  23.         //查看对象
  24.         System.out.println("s"+s);//sStudent@4554617c（是一个地址，表示当前这个Student在内存中的地址）
  25.         //调用属性和方法
  26.         System.out.println("姓名："+s.name);//姓名：null(null 表示空，对象是存在的，但是没有值--对象类型）
  27.         System.out.println("年龄："+s.age);//年龄：0（基本类型）
  28.         //给成员变量赋值
  29.         System.out.println("-------------------------");
  30.         s.name="Lynn";
  31.         s.age=18;
  32. //        s.sex="男";// 没有这个属性，所以不能直接调用
  33.         System.out.println(s.name);
  34.         System.out.println(s.age);
  36.         System.out.println("-------------------------");
  37.         //调用成员方法
  38.         s.study();
  39.         s.eat();
  40.     }
  41. }

练习

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-23-11:19
  4.  */
  5. public class Phone {
  6.     // 定义成员变量
  7.     String brand;
  8.     int price;
  9.     String color;
  10.     //定义成员方法
  11.     public void call(){
  12.         System.out.println("你的电话响啦！");
  13.     }
  14.     public void send(){
  15.         System.out.println("该干饭啦！");
  16.     }
  17.     public void paly(){
  18.         System.out.println("TiMi");
  19.     }
  20. }

2.7Java语言的特点：

强类型语言：必须经过编译才可以运行的
可移植性：一处编写，到处运行
面向对象

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-23-11:24
  4.  */
  6. /**
  7.  * 强类型语言：必须经过编译才可以运行的
  8.  * 可移植性：一处编写，到处运行
  9.  * 面向对象
  10.  *
  11.  * 编译期：程序员写好代码之后，按下保存按钮之后的事情--将Java代码编译成二进制的字节码文件，即.class，保存在bin目录下
  12.  * 运行期：代码执行的期间
  13.  */
  14. public class PhoneDemo {
  15.     public static void main(String[] args) {
  16.         //创建对象调用类
  17.         Phone p=new Phone();
  18.         //调用成员变量
  19.         p.brand="华为";
  20.         p.price=5699;
  21.         p.color="红色";
  22.         System.out.println("品牌："+p.brand);
  23.         System.out.println("价格："+p.price);
  24.         System.out.println("颜色："+p.color);
  25.         //调用方法
  26.         p.call("Lynn");//实参
  27.         p.send();
  28.         p.paly();
  29.     }
  31. }
  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-23-14:30
  4.  */
  6. /**
  7.  *
  8.  */
  9. public class PhoneDemo02 {
  10.     public static void main(String[] args) {
  11.         //实例化第一个对象
  12.         Phone p1=new Phone();
  13.         p1.brand="索尼";
  14.         p1.price=1999;
  15.         p1.color="黑色";
  16.         System.out.println(p1.brand+","+p1.price+","+p1.color);
  18.         //实力化第二个对象
  19.         Phone p2=new Phone();
  20.         p2.brand="iPhone";
  21.         p2.price=6999;
  22.         p2.color="黑色";
  23.         System.out.println(p2.brand+","+p2.price+","+p2.color);
  24.     }
  25. }
  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-23-14:34
  4.  */
  5. public class PhoneDemo03 {
  6.     //main方法，程序的主入口，必须写成字符串类型(String[]),args是一个参数（形参）
  7.     public static void main(String[] args) {
  8.         //创建对象调用类
  9.         Phone p=new Phone();
  10.         //调用成员变量（赋值）
  11.         p.brand="华为";
  12.         p.price=5699;
  13.         p.color="红色";
  14.         System.out.println(p.brand+","+p.price+","+p.color);
  16.         //把对象p赋值给p2
  17.         Phone p2=p;
  18.         //两个对象的地址相同
  19.         System.out.println(p2);//Phone@4554617c
  20.         System.out.println(p);//Phone@4554617c
  22.         //为p2进行再赋值
  23.         p2.brand="iPhone";
  24.         p2.price=6999;
  25.         p2.color="黑色";
  26.         System.out.println(p2.brand+","+p2.price+","+p2.color);//iPhone,6999,黑色
  27.         System.out.println(p.brand+","+p.price+","+p.color);//iPhone,6999,黑色
  29.     }
  30. }

image.png

2.8成员变量和局部变量的区别：

1.在类中位置不同
成员变量：在类中，方法外
局部变量：方法内或者声明上（参数列表）
2.在内存中的位置不同
成员变量—-堆内存中
局部变量—-栈内存中
3.生命周期不同
成员变量—-随着对象的存在而存在，随着对象的消失而消失
局部变量—-随着方法的调用而存在，随着方法的运行完毕而消失
4.初始化值不同—Java中规定的
成员变量—-有默认的初始化值
局部变量—-没有默认的初始化值—-必须先声明，赋值，才能使用

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-23-15:05
  4.  */
  6. /**
  7.  * 成员变量和局部变量的区别：
  8.  * 1.在类中位置不同
  9.  * 成员变量：在类中，方法外
  10.  * 局部变量：方法内或者声明上（参数列表）
  11.  *
  12.  * 2.在内存中的位置不同
  13.  * 成员变量---堆内存中
  14.  * 局部变量---栈内存中
  15.  *
  16.  * 3.生命周期不同
  17.  * 成员变量---随着对象的存在而存在，随着对象的消失而消失
  18.  * 局部变量---随着方法的调用而存在，随着方法的运行完毕而消失
  19.  *
  20.  * 4.初始化值不同--Java中规定的
  21.  * 成员变量---有默认的初始化值
  22.  * 局部变量---没有默认的初始化值---必须先声明，赋值，才能使用
  23.  */
  24. public class VailableDemo {
  25.     //成员变量
  26.     int x;
  28.     public void show(){
  29.         //方法内可以直接调用成员变量
  30.         System.out.println(x);
  32.         //局部变量
  33.         int y=9;
  34.         System.out.println(y);
  35.     }
  37.     public static void main(String[] args) {
  38.         //调用show方法
  39.         //1.首先要实例化对象(即创建对象）
  40.         VailableDemo v=new VailableDemo();
  41.         v.x=618;
  42.         v.show();
  43.     }
  46. }

2.9 private：

是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-23-15:22
  4.  */
  6. /**
  7.  * 当前案例中讲解数据的安全性
  8.  * 通过private这个关键字用于修饰数据进行数据的私有处理
  9.  *
  10.  * private：私有的
  11.  * 是一个权限修饰符
  12.  * 可以修饰变量方法
  13.  * 被private修饰的数据只能在本类中被访问
  14.  *
  15.  * 如果其他类中如要访问私有数据，可以申请访问：
  16.  * 即在当前类中声明get/set方法
  17.  */
  18. public class Student01 {
  19.     //成员变量---属性
  20.     String name;
  21.     private int age;
  23.     //声明set方法
  24.     public void setAge(int a){
  25.         //正常人的年龄0~200
  26.         if(a<0 || a>200){
  27.             System.out.println("非人类");
  28.         }else{
  29.             age=a;
  30.         }
  31.     }
  33.     //声明get方法
  34.     public int getAge(){
  35.         return age;
  36.     }
  38.     //展示学生信息
  39.     public void show(){
  40.         System.out.println("姓名："+name+","+"年龄："+age);
  41.     }
  42. }
  1. import java.sql.SQLOutput;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-23-15:23
  6.  */
  7. public class StudentDemo01 {
  8.     public static void main(String[] args) {
  9.         Student01 s=new Student01();
  10.         System.out.println(s.getAge());//申请访问age属性
  11.         s.show();
  13.         //赋值
  14.         s.name="张三丰";
  15.         s.setAge(150);// 走setAge方法
  16. //        s.setAge(250);// 走setAge方法
  18.         //展示信息
  19.         s.show();
  20.     }
  22. }
  23. 结果：
  24. 0
  25. 姓名：null,年龄：0
  26. 非人类  //这个数据显示在前面是因为，150这个数据在Student01中开始没有被打印，
  27. //250这个数据显示打印出来，然后在调用show方法中
  28. 姓名：张三丰,年龄：150

private最常见的应用：

把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用

3.封装

封装概述

是面向对象三大特征之一
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像上章说的年龄。

封装原则：

将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法

好处：

通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

3.2this关键字

this: 代表所在类的对象引用
记住：方法被哪个对象调用，this就代表那个对象
什么时候使用this呢? 局部变量隐藏成员变量

  1. package com.igeek_02;
  3. /**  
  4. * @ClassName: Student  
  5. * @Description: 学生类
  6. * @date 2017年11月10日 下午5:14:25    
  7. * Company www.igeekhome.com
  8. *    
  9. *    起名字我们要求做到见名知意。
  10. *    而我们现在的代码中的n和a就没有做到见名知意，所以我们要改进。
  11. *    
  12. *    如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近原则。
  13. *    
  14. *    我们有没有办法把局部变量的name赋值给成员变量的name呢？有
  15. *    
  16. *    什么办法呢？
  17. *        用this关键字就可以解决这个问题。
  18. *    
  19. *    this:    代表所在类的对象引用
  20. *            方法被哪个对象调用，this就代表那个对象
  21. *    
  22. *    使用场景：    局部变量隐藏成员变量
  23. */
  24. public class Student {
  25.     /**  
  26.     * @Fields name : 姓名  
  27.     */  
  28.     private String name;
  29.     /**  
  30.     * @Fields age : 年龄  
  31.     */  
  32.     private int age;
  34.     /**  
  35.     * @Title: setName  
  36.     * @Description: 设置姓名  
  37.     * @param n    
  38.     */
  39.     public void setName(String name){//吴京
  40.         //name=name;
  41.         this.name=name;
  42.     }
  44.     /**  
  45.     * @Title: getName  
  46.     * @Description: 获取姓名  
  47.     * @return    
  48.     */
  49.     public String getName(){
  50.         return name;
  51.     }
  53.     /**  
  54.     * @Title: setAge  
  55.     * @Description: 设置年龄  
  56.     * @param a    
  57.     */
  58.     public void setAge(int age){
  59.         //age=age;
  60.         this.age=age;
  61.     }
  63.     /**  
  64.     * @Title: getAge  
  65.     * @Description: 获取年龄  
  66.     * @return    
  67.     */
  68.     public int getAge(){
  69.         return age;
  70.     }
  72. }
  1. package com.igeek_02;
  3. /**  
  4. * @ClassName: StudentDemo  
  5. * @Description: 学生类的测试类
  6. * @date 2017年11月10日 下午5:17:34    
  7. * Company www.igeekhome.com
  8. *    
  9. */
  10. public class StudentDemo {
  11.     public static void main(String[] args) {
  12.         //创建学生对象
  13.         Student s=new Student();
  14.         System.out.println(s.getName()+"---"+s.getAge());
  16.         s.setName("吴京");
  17.         s.setAge(35);
  18.         System.out.println(s.getName()+"---"+s.getAge());
  19.     }
  20. }

4.构造方法

4.1构造方法作用概述

给对象的数据进行初始化
构造函数：

  • 又称为构造器
  • 作用：初始化全(成)员参数—主要是在构造函数中初始化的参数，在整个的类中都可以直接调用

    4.2构造方法格式

    方法名与类名相同
    没有返回值类型，连void都没有
    没有具体的返回值 ```java package com.hdzx_06;

import javax.sound.midi.Soundbank;

/**

  • @author Lynn
  • @create 2020-11-23-16:18 */

/**

  • 构造函数：
  • 又称为构造器
  • 作用：初始化全(成)员参数—主要是在构造函数中初始化的参数，在整个的类中都可以直接调用 *
  • 格式：
  • 1.构造函数的方法名与类名完全一致（包括大小写）
  • 2.没有返回值类型，不需要写void

  • 3.没有具体的返回值—没有return */ public class Student { //声明两个属性 private String name; private int age;

    public String getName() {

    1.  return name;

    }

    public void setName(String name) {

    1.  this.name = name;

    }

    public int getAge() {

    1.  return age;

    }

    public void setAge(int age) {

    1.  this.age = age;

    }

    //写一个(无参)构造函数 public Student(){

    1.  System.out.println("我是一个Student类的构造函数");

    } } java package com.hdzx_06;

import java.sql.SQLOutput;

/**

  • @author Lynn
  • @create 2020-11-23-16:18 */ public class StudentDemo { public static void main(String[] args) {
    1.  //调用了构造函数--实例化Student这个类
    2.  Student s=new Student();
    // System.out.println(s); // s.setName(“宋祖儿”); // s.setAge(18); // System.out.println(s.getName()+””+s.getAge()); }

}

  1. <a name="qNyWd"></a>
  2. ### 4.3构造方法注意事项 
  3. 如果你不提供构造方法，系统会给出默认构造方法 <br />如果你提供了构造方法，系统将不再提供 <br />构造方法也是可以重载的
  4. <a name="wqQ5u"></a>
  5. #### 方法重载：在Java中，同一个类中的多个方法可以有相同的方法名称，但是有不同的参数列表，这就称为方法重载（method overloading）。
  6. 说明：
  8. - 参数列表不同包括：个数不同、顺序不同、类型不同。
  9. - 仅仅参数变量名称不同是不可以的。
  10. - 跟成员方法一样，构造方法也可以重载。
  11. - 声明为final的方法不能被重写。
  12. - 声明为static的方法不能被重载，但是能够被在此声明。
  13. <a name="5CULd"></a>
  14. #### 方法的重载的规则：(同一个类，相同方法名，参数列表不同)
  16. - 方法名称必须相同。
  17. - 参数列表必须不同。
  18. - 方法的返回类型可以相同也可以不相同。
  19. - 仅仅返回类型不同不足以称为方法的重载。
  21. 判断是否是重载：<br />跟权限修饰符、返回值类型、形参变量名、方法体都没有关系
  22. <a name="OebXJ"></a>
  23. # 5.标准类的代码写法和测试
  24. <a name="TN7LW"></a>
  25. ### 5.1 类
  26. - 成员变量 <br />- 构造方法 <br />ž  无参构造方法 <br />ž  带参构造方法 <br />- 成员方法 <br />ž  getXxx()<br />ž  setXxx()
  27. ```java
  28. package com.hdzx_06;
  30. /**
  31.  * @author Lynn
  32.  * @create 2020-11-23-16:38
  33.  */
  35. /**
  36.  * 这是一个实体类的模板
  37.  * 实体：将抽象的东西进行实体化的类就是实体类
  38.  * 通常需要封装属性，方法，get/set方法，toString方法，equals方法（后面讲解）
  39.  */
  40. public class Person {
  41.     //属性
  42.     private String name;
  43.     private int age;
  44.     private String sex;
  46.     //定义构造函数，目的是初始化全员参数，为了避免创建对象报错的问题，就讲有参和无参都写上
  47.     public Person(){
  49.     }
  50.     //定义有参构造函数
  51.     public Person(String name,int age,String sex){
  52.         //初始化参数
  53.         this.name=name;
  54.         this.age=age;
  55.         this.sex=sex;
  56.     }
  57.     // get/set
  58.     public String getName() {
  59.         return name;
  60.     }
  62.     public void setName(String name) {
  63.         this.name = name;
  64.     }
  66.     public int getAge() {
  67.         return age;
  68.     }
  70.     public void setAge(int age) {
  71.         this.age = age;
  72.     }
  74.     public String getSex() {
  75.         return sex;
  76.     }
  78.     public void setSex(String sex) {
  79.         this.sex = sex;
  80.     }
  82.     @Override
  83.     public String toString() {
  84.         return "Person{" +
  85.                 "name='" + name + '\'' +
  86.                 ", age=" + age +
  87.                 ", sex='" + sex + '\'' +
  88.                 '}';
  89.     }
  90. }
  1. package com.hdzx_06;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-23-16:45
  6.  */
  7. public class PersonTest {
  8.     public static void main(String[] args) {
  9.         //实例化对象
  10.         Person s1=new Person();
  12.         Person s2=new Person("王俊凯",21,"中国");
  13.         System.out.println(s1);
  14.         System.out.println(s2);
  16.         System.out.println(s2.getName());
  18.     }
  19. }

5.2给成员变量赋值的方式

无参构造方法+setXxx()
带参构造方法 

  1. package com.igeek_04;
  3. /**  
  4. * @ClassName: StudentDemo  
  5. * @Description: 学生类的测试类
  6. * @date 2017年11月11日 上午9:26:15    
  7. * Company www.igeekhome.com
  8. *    
  9. */
  10. public class StudentDemo {
  11.     public static void main(String[] args) {
  12.         //无参构造方法+setXxx()方法
  13.         Student s=new Student();
  14.         s.setName("吴京");
  15.         s.setAge(35);
  16.         System.out.println(s.getName()+"---"+s.getAge());
  18.         //带参构造方法
  19.         Student s2=new Student("吴京", 35);
  20.         System.out.println(s2.getName()+"---"+s2.getAge());
  21.     }
  22. }