JavaSE学习（Day02）【类和对象的理解、封装、构造方法、this、Scanner类、Random类、匿名对象】

类和对象的理解

//创建一个Phone类（图纸）
public class DemoPhone {
     
    String brand;
    float price;
    String color;
    public static void name()
    {
     
        System.out.println("我属于xxx");
    }
}

//建立一个对象（实例）
public class PhoneOne {
     
    public static void main(String[] args) {
     
        DemoPhone firstPhone = new DemoPhone();
        firstPhone.brand = "苹果";
        firstPhone.price = 8888.0F;
        firstPhone.color = "灰黑";
        System.out.println(firstPhone.brand);
        System.out.println(firstPhone.price);
        System.out.println(firstPhone.color);
        firstPhone.name();
    }
}

类 = 属性+方法

面向过程：线性思维（处理简单的问题）
面向对象：分类的思维模式（处理复杂的问题）->处理复杂的问题就是将问题分类成简单的小问题然后再对小问题进行面向过程的思想去解决
面向对象相当于设计一个框架--->面向过程是执行的流程
两者不能分割

面向对象编程的本质就是：以类的方式组织代码，以对象的形式（封装）数据
面向对象编程的三大特性：

• 封装
• 继承
• 多态

抽象 == ‘抽像’，将共同的东西分离出来
对象，是具体的事物
类，是抽象（抽像）

例：
	 对象：小王、小明、小凯...  ->每一个具体的
	  类：  学生               ->‘抽像’：有共同的特征

从认识论的角度，先有对象才能通过（抽像）产生类
从代码运行角度，先有类后有对象 --> 类是对象的模板

封装

封装性（黑匣子）在Java中的体现

1、方法就是一种封装
2、关键字private也是一种封装

Person类

public class Person {
     
    String name;
    int age;
    public void show(){
     
        System.out.println("我叫"+name+"我"+age+"岁了");
    }
}

Person类的一个对象（实例）PersonOne

public class PersonOne {
     
    public static void main(String[] args) {
     
        Person wang = new Person();
        wang.age = -50; //不合理数字
        wang.name = "wang";
        wang.show();
    }
}

问题：
    发现有不合理的数值被设置。
解决方案：
    用Private关键字将需保护的成员变量进行修饰

一旦使用了private进行修饰，本类依然可以随意访问，但是，超出本类范围之外就不能直接访问，可间接访问。

间接访问private成员变量，就是定义一对getter、setter方法
命名规则setXxx、getXxx

特殊的：
	    对于基本类型的boolean值，Getter方法一定要写成isXxx的形式

修改后的Person类

public class person {
     
    String name;
    private int age;
    public void show(){
     
        System.out.println("我叫"+name+"我"+age+"岁了");
    }
    //这个成员方法，专门用于向age设置数据
    public void setAge(int num){
     
        if(num<100 && num > 0){
     
            age = num;
        }else{
     
            System.out.println("不合理");
        }
    }
    //这个成员方法，专门获取age的数据
    public int getAge(){
     
        return age;
    }
}

修改后的Person类的一个对象（实例）PersonOne

public class PersonOne {
     
    public static void main(String[] args) {
     
        person wang = new person();
//        wang.age = -50; //不合理数字//不能直接访问private内容
        wang.setAge(20);
        wang.show();
    }
}

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象是，其实就是在调用构造方法。

格式：

    public 类名称（参数类型 参数名称）{
     
        方法体
    }

注意事项：
1、构造方法的名称必须和所在的类名称完全一样
2、构造方法不要写返回值类型
3、构造方法不能return一个具体的返回值
4、如果不编写构造方法，那么编译器会默认写一个没有参数的构造方法，且方法体什么事都不做
public Student(){}
5、一旦编写的至少一个构造方法，那么编译器将不会默认有上面的构造方法，得自己加一个构造方法
6、构造方法也是可以进行重载。
    重载：方法名称相同，参数列表不同

public class Student {
     
    private String name;
    private int age;
    //写一个构造方法
    public Student(){
     
        System.out.println("执行无参构造方法!");
    }
    public Student(int age,String name){
     
        System.out.println("执行有参构造方法!");
        this.name = "ww";
        this.age = 2;
    }

    //快捷键Alt+insert
    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 class DemoStudent {
     
    public static void main(String[] args) {
     
        Student stu = new Student();//Student()就是构造方法的调用--->无参构造
        Student stu1 = new Student(20,"fx");//有参构造
    }
}

this关键字

当方法的局部变量和类的成员变量重名时，“就近原则”，优先使用局部变量
若要访问本类中的成员变量，则使用:   this.成员变量名

public class Person {
     
    String name;
    public void sayHello(String name){
     
        System.out.println(name+"你好，我是"+this.name);
    }
}

public class DemoPerson {
     
    public static void main(String[] args) {
     
        Person fanXing = new Person();
        fanXing.name = "FX";
        fanXing.sayHello("xx");
    }
}

Scanner类

Scanner类的功能：可以实现键盘输入数据到程序中（首字母大写说明是一个类String）

引用类型(除基本类型)的一般使用步骤：

1、导包--------->  import 包路径.类名称;
如果需要使用的目标类，和当前类位于同一个包下，可以省略导包
只有Java.lang包下的内容不需要导包，其他的包都需要

2、创建
类名称 对象名 = new 类名称();    //类名称()其实是类的无参构造方法

3、使用
对象名.成员方法名()

import java.util.Scanner;//1、导包
public class ScannerDemo {
     
    public static void main(String[] args) {
     
        //2、创建
        //备注：System.in代表从键盘进行输入
        Scanner sc = new Scanner(System.in);

        //3.获取键盘输入int数字
        int num = sc.nextInt();//next就是输入字符串+Int就是将字符串转化为int的形式
        System.out.println("输入的int数字是："+ num);

        //4.获取键盘输入的字符串      见到空格就停下
        String str = sc.next();//next就是输入字符串
        System.out.println("输入的字符串是："+ str);

        //5.获取键盘输入的字符串       见到回车才停下
        String str1 = sc.nextLine();
        System.out.println("输入的字符串是："+ str1);
    }
}

next输入有效字符之前，见到空格将空格去掉；输入有效字符之后，见到空格就结束
nextLine见到回车结束，可以接受空格

Random类

Random类用来生成随机数字。

1、导包
import java.util.Random;

2、创建
Random r = new Random();

3、使用
获取一个随机的int数字（范围为int所有范围，正负两种）：int randomNum = r.nextInt();
获取一个随机的int数字（参数代表了范围，左闭右开区间）：int randomNum = r.nextInt(3);
实际上代表的含义是：[0,3)(整数)也就是0~2

public class Demo01Random {
     
    public static void main(String[] args) {
     
        Random r = new Random();

        int randomNum = r.nextInt();
        System.out.println(randomNum);
    }
}

匿名对象

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new 类名称();

注意事项：
    匿名对象只能使用唯一一次
使用建议：
    如果确定对象只是使用一次就可以用

创建对象的标准格式
类名称 对象名 = new 类名称();

public class Person {
     
    String name;
    public void say(){
     
        System.out.println("我叫"+name);
    }
}

public class Demo {
     
    public static void main(String[] args) {
     
    //左边的one就是对象的名字
        Person one = new Person();
        one.name = "fanxing";
        one.say();
        System.out.println("===================");

        //匿名对象
        new Person().name = "ff";
        new Person().say();//我叫NULL
    }
}