Day06JavaSE——类与对象

Day06JavaSE——类与对象

c:构造方法	通过对象直接访问成员变量是不被允许的，这样会导致一些未知的错误，所以在日常使用时，我们将成员变量通常设置成private权限，这样就不能在成员变量所在类外去通过对象直接调用成员变量，我们通过一个成员变量建立两个类来对成员变量进行赋值与调用
面向类的思想
类与对象及其应用
	如何创建标准Java类库中的类对象
	如何编写自己的类
对象的内存图
成员变量和局部变量的区别
匿名对象
封装（private）
this关键字

面向对象概述

在了解什么是面向对象之前首先要搞清楚什么是面向过程，从而更深刻的理解面向对象思想的特点以及两者的区别

A:面向对象思想概述
	在试想一个简单的功能时，需要程序员自己通过一步一步的算法去实现和操作。每一个步骤都是参与者，并且需要程序员自己去编写每一个步骤的代码，这就是面向过程的开发。
	那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
	面向过程的代表语言：C语言
B：面向对象思想
	面向对象程序设计(简称OOP)，每个对象都包含对用户公开的特定功能部分和隐藏的实现部分。
	在OOP中，不必关心对象的具体实现，只要能够满足用户的需求即可。
	并且OOP中，数据是第一位的，然后再考虑操作数据的算法。
C:面向对象思想特点
	a:是一种更符合我们思想习惯的思想 懒人思想
	b:可以将复杂的事情简单化 
	c:将我们从执行者变成了指挥者
		角色发生了转换
D:面向对象的特征
	封装(encapsulation)
	继承(inheritance)
	多态(polymorphism)

类与对象的区别

A:我们学习编程是为了什么
	我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
B:我们如何描述现实世界事物
	举例: 描述学生事物
		 	姓名 , 年龄 , 性别 ....
			学习 , 吃饭 , 睡觉 ....	
	
	属性:	就是该事物的描述信息
	行为:	就是该事物能够做什么
	我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
	由此我们就得到了现实中的事物和类的对应关系
		事物				       类
		属性	----------------- 成员变量
		行为	----------------- 成员方法
C:定义类其实就是定义类的成员(成员变量和成员方法)
	a:成员变量	和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
	b:成员方法	和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
	
D:类和对象的概念
	a:类：是一组相关的属性和行为的集合
	b:对象：是该类事物的具体体现
	c:举例：
		类	学生
		对象	班长就是一个对象

类的使用语法

A:文件名问题
	在一个java文件中写两个类：一个基本的类，一个测试类。
	建议：文件名称和测试类名称一致。
B:如何使用呢?
	创建对象使用。
C:如何创建对象呢?
	格式：类名 对象名 = new 类名();
D:如何使用成员变量呢?
	格式：对象名.变量名
E:如何使用成员方法呢?
	格式：对象名.方法名(...)

一个类可以有多个对象

利用面向对象的思想分析例子

创建person类的对象

//在主函数中创建Person对象，并调用Person类中的成员变量(属性)和成员方法(功能)
public class Mytest1{
    public static void main(String[] args){
        /*类名    对象名      =  new 类名();
          new关键字会在堆内存区开辟空间*/
        Person person     =   new Person();
        //适用对象来调用属性和功能
        String name=person.name;
        int age=person.age;
        char sex=person.sex;
        //调用类的功能  对象名.方法名()
        person.eat();
        person.sleep();
        person.playGame();
        
        //再创建一个person对象
        Person p1 = new Person();
        p1.name="李四";
        p1.age=30;
        p1.sex='女';

        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.sex);

        p1.sleep();
        p1.eat();
        p1.playGame();
        
        //再创建一个person对象
        Person p2 = person;
        System.out.println(p2.name);
        System.out.println(p2.age);
        System.out.println(p2.sex);
        p2.sleep();
        p2.eat();
        p2.playGame();
	}
}

//定义一个类
public class Person{
    //定义成员变量：成员变量位于类中，方法外
    String name="张三";
    int age=23;
    char sex='男';
    
    //定义成员方法。
    public void sleep(){
        System.out.println("sleep");
    }
    public void eat(){
        System.out.println("eat");
    }
    public void playGame(){
        System.out.println("Play game");
    }    
}

一个对象内存图解

两个对象内存图解

三个对象内存图解

学生

public class MyTest3 {
    public static void main(String[] args) {
        //创建Student类的对象student，以引用Student类中的属性与功能
        Student student=new Student();
        //用student对象去引用Student类中的属性
        String name=student.name;
        int age = student.age;
        String  sex = student.sex;
        double score = student.score;

        name="李四";
        System.out.println(name);
        System.out.println(age);
        System.out.println(sex);
        System.out.println(score);

        //引用功能
        student.eat();
        student.sleep();
        student.study();
    }
}

public class Student {
    String name="张三";
    int age;
    String sex;
    double score;

    public void study() {
        System.out.println("学习");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}

面向对象

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

A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

注意事项：: 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

public class MyTest5 {
    public static void main(String[] args) {
        /*面向对象：成员变量和局部变量的区别
        * 局部变量：定义在方法中的变量或者方法声明上的变量（形参）
        * 成员变量：定义在类中，方法外的变量
        *
        * 成员变量和局部变量的区别：
        * 1、局部变量属于方法，成员变量属于对象；
        * 2、局部变量随着方法的调用而产生，随着方法的调用完毕而消失
        * 3、成员变量随着对象的创建而产生，随着对象的执行完毕而消失；
        * 4、局部变量没有初始化值，必须赋值才能使用；成员变量有默认值；
        *5、局部变量存储在栈内存，
        * 成员变量存储在堆内存（new出来的全部在堆内存，
        * 并且随着程序执行完毕后不再被引用，被垃圾回收器回收）；
         *
         * 变量访问规则：当成员变量和局部变量重名后，在访问变量时，按照就近原则
         * 就近原则：先在局部范围找，如果找到这个变量，就使用；如果在局部范围没找到，就去成员范围找，如果找到就使用
         * */
        Phone p1 = new Phone();
        System.out.println(p1.age);
        p1.outPut("华为",899.9);
        p1.outPut();
    }
}

//我们可以在一个Java文件中，并列定义多个类。
// 但是只能在有主方法的类前面加Public，要么全部都不加权限修饰符
//建议一个类一个Java文件
class Phone{
    //定义在方法外，类中的为成员变量
    String brand="小米";
    int age=10;
    double price=799.9;

    //局部变量定义在方法中
    public void outPut(String brand,double price){
        System.out.println(brand+"牌子的手机，一个"+price+"元。");
    }
    
    //局部范围没找到这两个变量，就会去成员范围找
    public void outPut(){
        System.out.println(brand+"牌子的手机，一个"+price+"元。");
    }
}

方法的形参是类名的时候如何调用

A:Java中参数传递问题
形式参数
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
B:方法的参数是类名
如果你看到了一个方法的形式参数是一个类 类型(引用类型)，这里其实需要的是该类的对象。

匿名对象的概述和应用

A:什么是匿名对象
就是没有名字的对象
B:匿名对象应用场景
a:调用方法，仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递
C:案例演示
匿名对象应用场景

public class MyTest6 {
    public static void main(String[] args) {
        /*匿名对象：没有名字的对象*/
        new Student().show();
        //如果方法只调用一次，直接使用匿名对象调用，就很方便
        //如果我们想要使用同一个对象，把方法调用多次的时候
        //就不能使用匿名对象（每new一次，就会创建一个新的对象）
        Student s1 = new Student();
        s1.show();
        s1.show();
        s1.show();

        System.out.println("=====匿名对象可以作为参数传递=====");
        Student s2 = new Student();
        test(s2,20);
    }
    //匿名对象可以作为参数传递
    //如果看到一个方法的形参，要一个类 类型。你就传递一个该类的对象。
    public static void test(Student s2,int a) {
        s2.num=a;
        System.out.println(s2.num);
    }
}

class Student{
    int num=200;
    public void show(){
        System.out.println("hehe");
    }
}

封装的概述

A:封装的引入
通过学生案例，给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。
B:封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
C:封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
D:封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。

private关键字的概述和特点

A:private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问
B:案例演示
private关键字特点

public class MyTest {
    public static void main(String[] args) {
        //private 是一个权限 修饰符，可以修饰成员变量，和成员方法.
        //被修饰的成员，只能在本类中访问，外界无法直接访问。
        //权限修饰符 范围 public>protected>确省的>private
        Student student = new Student();
        int age = student.age;
        int num = student.num;
        int a = student.a;
        student.show();
        //类中私有的成员外界无法访问
        //student.show2();
    }
}

class Student{
   private String name;
   public int age;
   protected int num;
   int a;
   public void show(){
       System.out.println("abc");
       System.out.println(age);
       show2();
   }
    private void show2() {
        System.out.println("abc");
    }
}

private应用的标椎案例

A:private最常见的应用：
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法
B:案例演示
演示使用封装来完善我们的学生类

package mytest7;

public class MyTest7 {
    public static void main(String[] args) {
        /*封装：隐藏对象的属性和是想细节，仅对外提供公共访问方式*/
        //给成员变量设置值
        Student s1 = new Student();
        s1.name="张三";
        s1.sex="男";

        //设置年龄时，240我认为不合理
        //此时我们需要对给成员变量赋值时，需要进行校验，看是否合理，
        //以我们目前的这个语法 对象名.成员变量名=值  就给设置上去了
        //那么我们可以屏蔽掉这种语法不要以 对象名.成员变量名=值 这种方式
        //我们使用private关键字就可以屏蔽
        /*当Student中的age成员变量设置成了private权限
        这时就不能直接访问变量，因为private关键字将age的范围限制在了Student中
        所以我们需要通过公共方法来对age进行赋值与获取*/
        //s1.age=23;
        s1.setAge(50);
        s1.setAge(200);
        System.out.println(s1.getAge());
    }
}

public class Student {
    //修饰之后，改成员就只能在本类中访问，外界无法直接访问
    private int age;
    String name;
    //private是一个权限修饰符，可以修饰成员变量，成员方法
    String sex;
    //使用IDEA快速生成 get set 方法  alt+insert 弹出一个框 
    //选 getterAndseter选项 选择
    //我们为了让用户能够在外界给设置成私有权限的成员变量赋值，就需要去调用方法来给其赋值
    public void setAge(int nianling){
        if(nianling >=0 && nianling<=100){
            age=nianling;
        }else{
            System.out.println("输入错误");
        }
    }
    //我们还得提供获取成员变量的方法
    public int getAge(){
        return age;     //就近原则
    }
}

this关键字的概述和应用、

A:为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
B:this关键字特点
是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁
C:this的应用场景
解决局部变量隐藏成员变量
D:案例演示
this的应用场景

public class MyTest9 {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println("调用者" + s1);
        s1.setName(s1,"王老虎");
        s1.setAge(s1,30);

        String name = s1.getName();
        int age = s1.getAge();
        System.out.println(name);
        System.out.println(age);

        System.out.println("==========================");
        Student student2 = new Student();
        System.out.println("调用者" + student2);
        student2.setName(student2, "王老虎");
        student2.setAge(student2, 30);

        String name2 = student2.getName();
        int age2 = student2.getAge();
        System.out.println(name2);
        System.out.println(age2);
    }
}

//当成员变量和局部变量重名了，就需要用this关键字来区分
//
class Student{
    private String name;
    private int age;

    public void setName(Student s1,String name){
        System.out.println("方法中的this 代表"+this);
        //当成员变量和局部变量重名了，我们怎么区分
        //我们可以使用this关键字来取分
        //this 他代表本类的一个引用，你可以认为是本类的一个对象，那么哪个对象调用这个方法，这个方法中的this就代表这个对象。
        this.name=name;
        s1.name = name;
        System.out.println("传过来的student"+s1);
        System.out.println(this == s1);
    }
    public void setAge(Student student,int age) {
        System.out.println("方法中的this 代表" + this);
        this.age = age;
        //student.age = age;
        System.out.println("传过来的student" + student);
        System.out.println(this==student);
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

标准的学生类代码及其测试

A:案例演示: 把手机类的成员用private修饰,给出getXxx()/setXxx()方法

public class MyTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        System.out.println(phone.getBrand());
        System.out.println(phone.getColor());
        System.out.println(phone.getPrice());

        phone.setBrand("小米");
        phone.setColor("黑");
        phone.setPrice(799.9);

        System.out.println(phone.getBrand());
        System.out.println(phone.getColor());
        System.out.println(phone.getPrice());
    }
}

public class Phone {
    private String brand;
    private String color;
    private double price;

    public void setBrand(String brand){
        this.brand=brand;
    }
    public void setColor(String color){
        this.color=color;
    }
    public void setPrice(double price){
        this.price=price;
    }
    //使用IDEA快速生成get set方法 alt+insert弹出一个框，选择即可
    public String getBrand(){return brand;}
    public String getColor(){return color;}
    public double getPrice(){return price;}
}

}
}

```java
public class Phone {
    private String brand;
    private String color;
    private double price;

    public void setBrand(String brand){
        this.brand=brand;
    }
    public void setColor(String color){
        this.color=color;
    }
    public void setPrice(double price){
        this.price=price;
    }
    //使用IDEA快速生成get set方法 alt+insert弹出一个框，选择即可
    public String getBrand(){return brand;}
    public String getColor(){return color;}
    public double getPrice(){return price;}
}