Java_Day10(对象、成员变量和局部变量、private、this、构造方法、标准的Java类、String)

Java_Day10(对象、成员变量和局部变量、private、this、构造方法、标准的Java类、String)

面向对象

类和对象：

1. 类：
   具有共同属性和行为的一类事物的抽象表示
2. 对象：
   是类的具体化，万物皆对象
3. 属性：
   成员变量
4. 行为：
   成员方法

类的定义：

public class Phone {
    // 属性:
    //      成员变量 ：位于类的内部 方法的外部 其他的使用方式和之前变量的 定义一致
    String  brand;
    double price;
    //行为：
    //    成员方法 ： 去掉之前方法 中的static即可
    //打电话
    public void  call(){    
    }
    public void  sms(){
    }
}

对象的创建和使用：

public static void main(String[] args) {
    // 创建对象
    Phone  p = new Phone();
    //使用对象
    // 为成员属性赋值
    p.brand = "华为";
    p.price = 2999.99;
    // 获取属性
    System.out.println(p.brand);
    System.out.println(p.price);
    // 调用成员方法
    p.call();
    p.sms();
}

成员变量和局部变量

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

private

访问修饰符，可以修饰成员变量和成员方法
被修饰的成员只能在当前类中访问
当成员变量被private修饰之后，必须使用setter和getter访问和修改
setter和getter写法是固定的，必须用public 修饰，方法名称是set属性名（get属性名），且属性名首字母大写

public class Student {
    /*成员变量和局部变量的 区别
        1从位置：成员变量位于类的内部 方法的外部
                局部变量   类的内部 方法的 内部 （方法内的参数以及方法的 形参）
        2 作用域： 成员变量 是整个类
                   局部变量： 仅限于所在方法
        3 默认值： 成员变量有默认值  默认值和数组相同
                   局部变量 没有默认值 要求在第一次使用之前必须初始化

     */
   private String  name;
   private int  age;
   // 提供获取/设置私有属性的 方法
    public  void setName(String n){
        name= n;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        if(a >= 0   &&  a < 100){
            age =a;
        }else{
            System.out.println("年龄赋值非法");
            return;
        }
    }
    public int getAge(){
        return  age;
    }
    //成员方法
    public  void study(){
        System.out.println("正在努力学习");
    }
    public   void  doHomework(){
        System.out.println("完成作业...");
    }
}
class  StudentTest{
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("迪丽热巴");
        student.setAge(250);
        System.out.println(student.getName() +"----"+student.getAge());
    }
}

this

this表示当前对象，this代表是当前方法调用的对象
作用：

1. 用来区分同，名的成员变量和局部变量
2. 在代码中需要明确的指代当前使用的成员是当前对象的成员时使用this表示

public class Student {
   private String  name;
   private int  age;
   // 提供获取/设置私有属性的 方法
    public  void setName(String name){
        System.out.println(name);
        this.name= name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        if(age >= 0   &&  age < 100){
            this.age =age;
        }else{
            System.out.println("年龄赋值非法");
            return;
        }
    }
    public int getAge(){
        return  this.age;
    }
    //成员方法
    private  void study(){
        System.out.println("正在努力学习");
    }
    public   void  doHomework(){
        System.out.println("完成作业...");
    }
}

构造方法

作用：

1. 创建对象
2. 完成对象属性的初始化

访问修饰符：public private
方法的返回值类型：无返回值，且不写void
方法名称：和类名相同
参数列表：根据需求罗列

在没有手动创建构造方法时JVM会默认提供一个无参的构造方法
构造方法的执行实际：当创建对象的时候就会被调用 。而且每创建 一个对象 ，构造方法就会被调用一次

自定义构造方法：

public  Student(){
    System.out.println("构造方法被调用....");
};
public Student(String name){
    this.name = name;
}

且构造方法可以重载：

public  Student(){
    System.out.println("构造方法被调用....");
};
public Student(String name){
    this.name = name;
}
public Student (int age){
    this.age = age;
}
public  Student(String name ,int age){
    this.name= name;
    this.age = age;
}

在构造方法中如果要调用其他的重载的构造方法，可以使用this();但是使用this()调用其他的构造,方法只能调一次(因为再构造方法中使用this调用其他构造方法的语句必须出现在当前构造方法的 第一行)

标准的Java类

类的组成：

1. 构造方法
2. 成员变量
3. 成员方法

细节：

1. 构造方法需要多个，至少需要包含无参构造
2. 成员变量必须使用private修饰 同时提供getter和setter方法

标准的Java类：

//在一个标准的 java类中，只存在和当前类相关的 属性和方法
public class Person {
    // 定义成员变量
    private String name;
    private int age;
    private String job;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, String job) {
        this.name = name;
        this.age = age;
        this.job = job;
    }

    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 String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }
    public void show(){
        System.out.println(this.getName()+"----"+this.getAge()+"---"+this.job);
    }

}

字符串-String

• String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
• 字符串不变; 它们的值在创建后不能被更改。 字符串缓冲区支持可变字符串。 因为String对象是不可变的，它们可以被共享。

String类包括用于检查序列的各个字符的方法，用于比较字符串，搜索字符串，提取子字符串以及创建将所有字符翻译为大写或小写的字符串的副本

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc

public static void main(String[] args) {
    String str1 = new String("java");
    String str2 = "abc";//最常用的方式
    byte[] bytes = "hello".getBytes();
    String str3 = new String(bytes);
    char[] chars = {'w','r','o','l','d'};
    String str4 = new String(chars);
    System.out.println(str1);
    System.out.println(str2);
    System.out.println(str3);
    System.out.println(str4);
}

public static void main(String[] args) {
    String str1 = new String("java");
    String str2 = new String("java");
    String str3 = "java";
    String str4 = "java";
    String str5 = "ja"+"va";
    String str6 = "ja";
    String str7 = "va";
    String str8 = str6 + str7;
    System.out.println(str1 == str2);//false
    System.out.println(str1 == str3);//false
    System.out.println(str3 == str4);//true
    System.out.println(str4 == str5);//true
    System.out.println(str5 == str8);//false

}