编码的思想

了解编码的思想(☆)

• 面向过程
  • 程序实现的每一步都需要程序员自己操作，不但关注结果，程序实现的过程也要关注
• 面向对象
  • 程序员只关注程序实现的结果，不关注程序实现的过程
• 类和对象(☆☆☆☆☆☆)
  • 对象：
    • 世间的所有事物都可以称之为对象，也叫万物皆对象
  • 类：
    • 对具有相同的属性和行为的类事物描述的概念，抽象的。
  • 封装
    • 面向对象的基本特征之一，基本特征有 封装 继承 多态
    • 优点
    • private 关键字
    • this 关键字
    • 局部变量和成员变量
      • 局部变量
      • 成员变量
  • 对象的内存图(了解)
    • 一个对象的内存图
    • 多个对象指向各自堆内存的内存图
    • 多个对象指向同一片堆内存的内存图
  • 构造方法(☆☆☆)
    • 作用：创建对象，并初始化属性值
    • 定义

1.了解编码思想

面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的
面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能
  
面向对象思想小结：
  符合我们思考问题的一种思想
  将复杂的问题简单化
  将执行者变成了指挥者
/*
    编码思想：
        面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的
        面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能
 */
public class Demo01 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55, 66, 77, 88, 99, 100};
        //格式化输出数组中的元素[11, 22, 33, 44, 55, 66, 77, 88, 99, 100]
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1)
                System.out.print(arr[i]);
            else
                System.out.print(arr[i] + ", ");
        }
        System.out.println("]");
        /*
        小结：取数组中元素过程的小结 编码取数组中的元素，都需要自己写代码实现，每一步都是亲力亲为，
            在取元素的过程中，我们不但关注结果还要关注你去元素的过程，这种编码方式叫：面向过程的编码思想
         */
        //

        //格式化输出数组中的元素[11, 22, 33, 44, 55, 66, 77, 88, 99, 100]
        System.out.println(Arrays.toString(arr));
        /*
        小结：取数组中元素过程的小结 只要关注输出结果，取元素的细节，不用我们超心，
        只关注结果不关注过程，这种编码方式叫：面向对象的编码思想
         */
    }
}

2. 类和对象

2.1 类和对象

类是对现实生活中一类具有共同属性和行为的事物的集合
  属性：拥有什么
  行为：能做什么
【类】就是对事物的一种描述，是一个概念

对象：生活中万物皆对象，对象的类的具体体现，是类的实体，或者叫类的实例   对象是根据类创建而来
 /*
    类是对现实生活中一类具有共同属性和行为的事物的集合
    属性:拥有什么
    行为：能做什么
    对象：是能够看得到摸的着的真实存在的实体, 对象是根据类创建而来
        对象是类的实体

 */
public class Demo02 {
    public static void main(String[] args) {

    }
}

2.2 类的组成

/*
类的组成：属性和行为
    属性：在类中通过成员变量来体现（类中方法外的变量）
    行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

    public class 类名{
         // 成员变量 == 属性
        数据类型 变量名1;
         // 成员方法 == 行为
         public 返回值类型 方法名(){
            方法体
         }
    }
    类名：符合标识符的命名规则，符合大驼峰的命名规范，做到见名知义

    成员变量名：符合标识符的命名规则，符合小驼峰的命名规范，做到见名知义
            在类中格式：数据类型 变量名1;
    成员方法名：符合标识符的命名规则，符合小驼峰的命名规范，做到见名知义
            在类中格式：public 返回值类型 方法名(){ 方法体 }
 */
public class Student {
    // 成员变量 == 属性
    //数据类型 变量名1;
    String name;
    int age;
    String school;
    // 成员方法 == 行为
    // 成员方法要去掉static关键字
    public void study(){
        System.out.println("GOOD GOOD STUDY DAY DAY UP");
    }
    public void opration(){
        System.out.println("做java开发");
    }
}

2.3 类的定义

 /*
        类的定义：
            属性在类中称为成员变量，位置在类中方法外
            行为在类中称为成员方法，位置在类中方法外，把static关键字去掉
        格式：
            public class 类名{
                成员变量
                ...
                成员方法
                ...
            }
        创建对象：
            格式：类名 对象名/变量名 = new 类名();
            Student s = new Student();
        对象的使用：
            1.对象调用成员变量
                对象名.成员变量名
                s.name
            2.对象调用成员方法
                对象名.成员方法名
                s.study()
     */
    public class Demo03Student {
        public static void main(String[] args) {
            //格式：类名 对象名/变量名 = new 类名();
            Student s = new Student();
            //对象的使用：
            // 1.对象调用成员变量 赋值
            s.name = "韩淳逸";
            s.age = 18;
            s.school = "家里蹲大学屋里系";
            // 1.对象调用成员变量 取值
            String name = s.name;
            int age = s.age;
            String school = s.school;
            System.out.println(name);
            System.out.println(age);
            System.out.println(school);
            //2.对象调用成员方法 对象名.成员方法名
            s.study();
            s.develop();
        }
    }

2.4 类的创建练习

 /*
        定义一个手机类：Phone
            品牌 brand
            价格 price
    
            打电话  call
            发短信  sendMessage
     */
    public class Phone {
        //成员变量
        String brand; //品牌
        double price; //价格
    
        //成员方法 call()，sendMessage()
        public void call() {
            System.out.println("打电话");
        }
    
        public void sendMessage() {
            System.out.println("发信息");
        }
    }

    /*
    需求：首先定义一个手机类，然后定义一个手机测试类，在手机测试类中通过对象完成成员变量和成员方法的使用
     */
    //定义手机测试类
    public class Demo04PhoneTest {
        public static void main(String[] args) {
            //创建手机对象
            Phone p = new Phone();
            //成员变量的赋值
            p.brand = "HUAWEI";
            p.price = 17988.0;
            //成员变量的取值
            String brand = p.brand;
            double price = p.price;
            System.out.println(brand);
            System.out.println(price);
            //成员方法的使用
            p.call();
            p.sendMessage();
        }
    }

    public class GirlFriend {
        //成员变量
        String name;
        int age;
    
        //成员方法
        public void wash() {
            System.out.println("女朋友给我洗衣服......");
        }
    
        public void cook() {
            System.out.println("女朋友给我做饭......");
        }
    
    }

    public class Demo05GirlFriendTest {
        public static void main(String[] args) {
            GirlFriend gf = new GirlFriend();
            //成员变量的赋值
            gf.name = "林青霞";
            gf.age = 18;
            //成员变量取值
            System.out.println(gf.name);
            System.out.println(gf.age);
    
            //成员方法的使用
            gf.wash();
            gf.cook();
    
            System.out.println("-----------------");
    
            GirlFriend gf2 = new GirlFriend();
            //成员变量的赋值
            gf2.name = "朱茵";
            gf2.age = 19;
            //成员变量取值
            String name = gf2.name;
            int age = gf2.age;
            System.out.println(name);
            System.out.println(age);
            //成员方法的使用
            gf2.wash();
            gf2.cook();
        }
    }

2.5 类的创建小结

/*
面向对象和面向过程的编码思想的对比：
面向过程：
就是编码每一个步骤都需要程序员，只实现，既关注过程，也关注结果
面向对象：
不关注程序实现的过程，只关注实现结果，从执行者变成了指挥者
万物皆对象，对象具体存在的事物
类：
是具有相同属性和行为的类事物的描述，是概念性的东西，是抽象的
对象：
对象是类的具体体现，也叫类的实例，也叫类的实体
定义一个类：
类的组成：属性和行为
属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
类定义的格式：
public class 类名{
成员变量 == 属性 格式：数据类型 属性名
成员方法 == 行为 格式：public 返回值类型 方法名(){方法体}
}
/
/
定义一个手机类：Phone
品牌 brand
价格 price

    打电话  call
    发短信  sendMessage

*/
public class Demo01类的定义小结 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
//遍历数组 打印到控制台 按照此格式打印：[1, 2, 3, 4, 5, 6, 7, 8, 9]
//1.面向过程的编码思想来实现
System.out.print(“[”);
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i]);
} else {
System.out.print(arr[i] + “, “);
}
}
System.out.println(”]”);
//2.面向对象的编码思想
System.out.println(Arrays.toString(arr));
}
}

3. 封装

3.1 private关键字

   import java.util.Scanner;
    
    public class Demo01 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            //创建学生对象
            Student s = new Student();
            //使用成员变量
            s.name = "杨帆";
            //正常的年龄大于0 小于等于180;
            System.out.println("请输入年龄：");
            int a = sc.nextInt();
            /*if (a > 0 && a <= 180) {
                s.age = a;
            } else {
                System.out.println("您输入年龄不合理！");
            }*/
            s.setAge(a);
    
            System.out.println(s.name);
            //System.out.println(s.age);
            System.out.println(s.getAge());
    
            Student s2 = new Student();
            s2.name = "蔡赛中";
            //正常的年龄大于0 小于等于180;
            System.out.println("请输入年龄：");
            int a2 = sc.nextInt();
            /*if (a2 > 0 && a2 <= 180) {
                s2.age = a2;
            }else {
                System.out.println("您输入的年龄不合理！");
            }*/
            s2.setAge(a2);
            System.out.println(s2.name);
            //System.out.println(s2.age);
            System.out.println(s2.getAge());
        }
    }

/*
    private 关键字 修饰的成员变量 只能在本类中访问，外界访问不了
        是一个权限修饰符
        可以修饰成员（成员变量和成员方法）
        被private修饰的成员只能在本类中才能访问

    封装：
        1.把成员变量封装起来，对外界提供getXXX和setXXX的方法，让外界方法

 */
public class Student {
    //属性 成员变量 格式： 数据类型 变量名
    String name;
    private int age;
    public void setAge(int a){
        if (a>0&&a<=180){
            age = a;
        }else {
            System.out.println("您给的年龄不合理");
        }
    }
    public int getAge(){
        return age;
    }
    //行为 成员方法
    public void study(){
        System.out.println("GOOD GOOD STUDY DAY DAY UP");
    }
    public void develop(){
        System.out.println("能做JAVAEE项目开发");
    }
}

3.2 this关键字

  /*
        变量的作用域：
            1.在所在的打括号中
            2.变量重名 就近原则
         this关键字：
            1.区分成员变量和局部变量 this修饰的重名变量名,表示是成员变量
            2.代表当前对象的引用，哪个对象调用此方法，此方法中this就是指哪个对象
            引用:对象在内存中的地址
     */
    public class Phone {
        private String brand;
        private double price;
    
        public void setBrand(String brand){
            this.brand = brand;
        }
        public String getBrand(){
            return brand;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
        public double getPrice(){
            return price;
        }
    }

  public class Demo02Phone {
        public static void main(String[] args) {
            Phone p = new Phone();
            p.setBrand("HUAWEI");
            p.setPrice(17998.0);
    
            System.out.println(p.getBrand());
            System.out.println(p.getPrice());
    
            Phone p2 = new Phone();
            p2.setBrand("XIAOMI");
            p2.setPrice(17899.0);
    
            System.out.println(p2.getBrand());
            System.out.println(p2.getPrice());
        }
    }

3.3 封装的练习

  /*
        成员变量私有化 外界不能直接访问
        提供getXxx和setXxx方法 让外界访问
    
        定义一个类的步骤：
            1.类名，符合大驼峰，做到见名知意
            2.成员变量私有化
            3.提供getXxx和setXxx方法 直接使用快捷键生成
     */
    public class Cat {
        private String breed;//品种
        private int age; //成员变量
    
        public String getBreed() {
            return breed;
        }
    
        public void setBreed(String breed) {
            this.breed = breed;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

 /*
        已知猫类 有品种breed 和年龄 age属性
        使用封装方式 定义猫类
     */
    public class Demo03Cat {
        public static void main(String[] args) {
            //创建对象
            Cat cat = new Cat();
            //使用set方法赋值
            cat.setBreed("波斯猫");
            cat.setAge(3);
            //使用get方法取值
            String breed = cat.getBreed();
            int age = cat.getAge();
            System.out.println(breed);
            System.out.println(age);
        }
    }

4. 构造方法

4.1 构造方法入门

  /*
        构造方法：
            1.作用：用来创建对象，并初始化常用变量的值
            2.格式1：无参的构造方法
                public 类名(){}
              格式2：有参的构造方法
                public 类名(参数列表){
                    ......
                }
            3.特点：
                3.1 如果类中没有构造方法，JVM会默认提供一个无参构造方法,如果类中有构造方法，JVM不会在提供无参构造方法
                3.2 构造方法可以重载
                3.3 构造方法没有返回值，void 也不能写
                3.4 构造方法中return关键字省略不写，如果非要写，只能return;
     */
    public class Demo01Cat {
        public static void main(String[] args) {
            Cat cat = new Cat();
            //System.out.println(cat);//com.itheima._04构造方法.Cat@776ec8df
    
            Cat cat1 = new Cat("波斯猫");
    
            Cat cat2 = new Cat(3);
    
            Cat cat3 = new Cat("狸花猫", 3);
        }
    }

 /*
        构造方法：
            1.作用：用来创建对象，并初始化常用变量的值
            2.格式1：无参的构造方法
                public 类名(){}
              格式2：有参的构造方法
                public 类名(参数列表){
                    ......
                }
            3.特点：
                3.1 如果类中没有构造方法，JVM会默认提供一个无参构造方法,如果类中有构造方法，JVM不会在提供无参构造方法
                3.2 构造方法可以重载
                3.3 构造方法没有返回值，void 也不能写
                3.4 构造方法中return关键字省略不写，如果非要写，只能return;
     */
    public class Demo01Cat {
        public static void main(String[] args) {
            Cat cat = new Cat();
            //System.out.println(cat);//com.itheima._04构造方法.Cat@776ec8df
    
            Cat cat1 = new Cat("波斯猫");
    
            Cat cat2 = new Cat(3);
    
            Cat cat3 = new Cat("狸花猫", 3);
        }
    }

4.2构造方法练习

  /*
        总结：
            1.类的创建：
                1.1 类名符合大驼峰，做到见名知意
                1.2 类的成员变量 私有化  private关键字
                1.3 提供getXxx和setXxx方法
                1.4 提供空参和满参的构造方法
            2.对象的创建
                在测试类的main方法中，使用new关键字和构造方法类创建对象
                就可以使用对象的非私有的成员变量和成员方法
     */
    public class Demo02Student {
        public static void main(String[] args) {
            //使用空参的构造方法创建对象
            Student stu = new Student();
            //使用set方法初始化成员变量的值
            stu.setName("董辉");
            stu.setAge(18);
            stu.setScore(99.9);
            //使用get方法获取成员变量的值
            System.out.println(stu.getName());
            System.out.println(stu.getAge());
            System.out.println(stu.getScore());
    
            //使用满参的构造方法创建对象初始化常用变量的值
            Student stu2 = new Student("陈亚琪",19,99.8);
            System.out.println(stu2.getName());
            System.out.println(stu2.getAge());
            System.out.println(stu2.getScore());
        }
    }

 public class Student {
        private String name;
        private int age;
        private double score;
        //空参构造方法
        public Student() {
        }
        //满参构造方法
        public Student(String name, int age, double score) {
    
            this.name = name;
            this.age = age;
            this.score = score;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public double getScore() {
            return score;
        }
    
        public void setScore(double score) {
            this.score = score;
        }
    }

4.3 打印对象输出地址

/*
    打印对象名 输出是地址
 */
public class Demo03 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println(cat);
        /*
        com.itheima._04构造方法.Cat@776ec8df
        com.itheima._04构造方法 ： 包名
        Cat ： 类名
        @:分隔符
        776ec8df ：对象在堆内存中地址

        com.itheima._04构造方法.Cat ： 包名+类名 又称为全类名

         */
    }
}

5.垃圾回收机制

 /*
        垃圾回收机制的意义:
            1.垃圾回收可以有效的防止内存泄露，有效的使用空闲的内存；
            2.它使得java程序员在编写程序的时候不在考虑内存管理
        引用计数算法:
            在对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加一；当引用失效时，计数器值就减一
            任何时刻计数器为零的对象就是不可能再被使用的.
        如何判断对象已经成为垃圾:
            当堆内存中，对象或数组产生的地址，通过任何方式都不能被找到后，就会被判定为内存中的“垃圾”
     */
    public class Demo01 {
    }

6.标准类的编写

  /*
        标准类的编写: 成员变量私有化 提供空参满参构造方法 提供getXxx和setXxx方法
            1.类名
                符合标识符的命名规则，符合 大驼峰 的命名规范，做到见名知义
            2.成员变量：
                符合标识符的命名规则，符合 小驼峰 的命名规范，做到见名知义
                成员变量私有化 private 关键字
                提供getXxx和setXxx方法让外界访问
            3.构造方法：
                提供空参构造方法
                提供满参的构造方法
     */
    public class Student {
        //成员变量私有化
        private String name;
        private int age;
        //提供空参满参的构造方法
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
        //提供getXxx和setXxx方法
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

 /*
    标准类制作: 成员变量私有化你，提供空参满参构造方法，提供getXxx和setXxx方法
        1.成员变量
            使用private修饰
        2.构造方法
            提供一个无参构造方法
            提供一个带多个参数的构造方法
        3.成员方法
            提供每一个成员变量对应的setXxx()/getXxx()
            提供一个显示对象信息的show() 可选的
    
        4.创建对象并为其成员变量赋值的两种方式
            无参构造方法创建对象后使用setXxx()赋值
            使用带参构造方法直接创建带有属性值的对象
     */
    public class Demo01 {
        public static void main(String[] args) {
            //无参构造方法创建对象后使用setXxx()赋值
            Student s1 = new Student();
            s1.setName("张三");
            s1.setAge(18);
            System.out.println(s1.getName());
            System.out.println(s1.getAge());
    
            //使用带参构造方法直接创建带有属性值的对象
            Student s2 = new Student("李四", 19);
            System.out.println(s2.getName());
            System.out.println(s2.getAge());
        }
    }

7.成员变量和局部变量的区别

 区别     		成员变量                 	局部变量                   
 类中位置不同 	类中方法外                	方法内或者方法声明上(形参)         
 内存中位置不同	堆内存                  		栈内存                    
 生命周期不同 	随着对象的存在而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的调用完毕而消失
 初始化值不同 	有默认的初始化值             没有默认的初始化值，必须先定义，赋值，才能使用

8.面向对象的特征

   /*
        面向对象的特征:
            封装：
                1.把类中属性使用private关键字封装起来 ，对外界提供getXxx和setXxx方法，然外界访问成员变量,提高了数据的安全性
                2.把具有相同功能的代码封装成方法，提高代码复用性
                3.把具有相同属性和行为一类事物封装成类
            继承：
                (就业班第一天会讲)
            多态：
                 (就业班第一天会讲)
     */
    public class Demo01面向对象的特征 {
        public static void main(String[] args) {
            //[1, 2, 3, 4, 5, 6, 7, 8, 9]
            int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
            printArray(arr);
        }
        //把具有相同功能的代码封装成方法，提高代码复用性
        public static void printArray(int[] arr) {
            System.out.print("[");
            for (int i = 0; i < arr.length; i++) {
                if (i == arr.length-1){
                    System.out.print(arr[i]);
                }else {
                    System.out.print(arr[i]+", ");
                }
            }
            System.out.println("]");
        }
    }