JAVA-学习-2-CSDN博客

一、类

1、类的定义

        把相似的对象划分了一个类。

        类指的就是一种模板，定义了一种特定类型的所有对象的属性和行为

        在一个.java的问题件中，可以有多个class，但是智能有一个class是用public的class。被声明的public的class，必须和文件名相同。

[访问修饰符] class 类名{
    成员变量-属性
    成员方法-行为
    内部类
    代码块
}

public class Car {
     String color;
     String brand;
     int door_num;

    public void start(){
        //启动
        System.out.println(color+"颜色"+door_num+"门"+brand+"车正在启动......");

    }
    public void speed(){
        //加速
        System.out.println(color+"颜色"+door_num+"门"+brand+"车正在加速......");
    }
    public void stop(){
        //停止
        System.out.println(color+"颜色"+door_num+"门"+brand+"车正在停止......");
    }
}

2、成员变量

java类的成员变量，都有默认值。

整数：0

浮点数：0.0

布尔：false

字符：'\u0000'

引用：null

java类的成员变量，在下面所有的方法中，都可以访问到。

3、局部变量

但是局部变量是没有默认值的。

原因：

JVM通过CLassLoader类加载器及进行类加载，过程设计到加载，准备、解析和初始化，类的成员变量初始化，是在JVM类加载的阶段完成。

区别：

成员变量：静态（static）成员变量、非静态成员变量（初始化阶段赋值，根据代码中的赋值情况，如果没有赋值，则使用默认值，有赋值，则使用代码中的赋值；当当对象实例化后，成员变量会随着对象分配到Java堆内存中）。

局部变量：存储在栈内存中

4、对象

4.1对象的定义

类是模板，通过模板创建出具体的实例，就是模板。

对象就是实际存在的某类事务的个体，也叫实例。

类和对象的关系，就是抽象和具体的关系。

创建对象的属性和方法：

类名 对象名=new 类名

4.2对象的使用

public class test1 {
    public static void main(String[] args) {
        Car car1 = new Car();
        car1.color="red";
        car1.brand="baoma";
        car1.door_num=4;
        car1.start();
        car1.speed();
        car1.stop();
    }

}

4.3对象创建的原理

①JVM运行时包括：程序计数器、Java栈、堆、本地方法栈、方法区

②当我们创建一个对象时候，同时操作了栈内存和堆内存

③在栈内存保存了这个对象的引用

④对象的属性保存在对内存中。

⑤操作对象都是通过引用来完成，一旦引用出栈，没有被引用的对象就变成了垃圾，被回收。

在编写类文件的时候，类是存储在硬盘上的，没有被加载到内存中。

在主方法中创建了这个类的对象后，它才会被加载到内存中进行处理。

案例：

public class Clock {
    int hour;
    int mintue;
    int second;
    String timeZone;

    public void showTime(){
        System.out.println("现在是"+timeZone+"时间"+hour+"时"+mintue+"分"+second+"秒");
    }

}

public class TestColck {
    public static void main(String[] args) {
        Clock clock1 = new Clock();
        clock1.hour=11;
        clock1.second=12;
        clock1.mintue=22;
        clock1.timeZone="beijing";

        clock1.showTime();

        Clock clock2 = new Clock();
        clock2.hour=12;
        clock2.second=12;
        clock2.mintue=22;
        clock2.timeZone="dongjing";
        clock2.showTime();
    }

}

4.4匿名对象

new Car().speed();

就调用一次。

5、封装（属性的私有访问）

①Java的封装就是信息隐藏技术。从属性的角度来说，有选择的提供数据。

②封装也涉及到了软件的耦合性：高内聚，低耦合。

③将属性私有处理，需要使用private关键字；

④使用private关键字来修饰的属性，只能在当前类中访问。

⑤对于私有属性，一般会提供公有的访问方法：getter setter。 //驼峰式编码风格

Clock类

public class Clock {
    private int hour;
    private int mintue;
    private int second;
    private String timeZone;
    public void setHour(int hour){  //局部变量
        //在当前方法中，出现了两个hour，一个是成员变量，一个是局部变量
        //使用this关键字来菊粉，加this 的表示是成员变量
        this.hour=hour;
    }
    public void setMintue(int mintue){
        this.mintue=mintue;
    }
    public void setSecond(int second){
        this.second=second;
    }
    public void setTimeZone(String timeZone){
        this.timeZone=timeZone;
    }
    public void showTime(){
        System.out.println("现在是"+timeZone+"时间"+hour+"时"+mintue+"分"+second+"秒");
    }

    public int getHour(){
        return hour;  //this.hour 也可以这样写
    }

    public int getMintue(){
        return mintue;
    }
    public int getSecond(){
        return second;
    }
    public String getTimeZone(){
        return  timeZone;
    }

}

Clock类的调用

public class TestColck {
    public static void main(String[] args) {
        Clock clock1 = new Clock();
        clock1.setSecond(11);
        clock1.setTimeZone("beijing");
        clock1.setHour(12);
        clock1.setMintue(13);
        clock1.showTime();

        //只想知道当前的小时和分钟
        //很明显这样写不可以
        System.out.println(clock1.hour+"时"+clock.mintue+"分");

        //提供Get方法返回对应的值
        System.out.println(clock1.getHour()+"时"+clock1.getMintue()+"分");

    }

}

但是这样定义太麻烦了，我们就定义了四个属性，如果不加private，那么就可以直接访问，现在我们加上，就要弄八个方法，这么多太麻烦了。

那么可以用简单的方式：

快捷键：按住alt+insert

直接生成。

这个getter和setter的写法也叫属性暴露！

6、构造方法

（1）构造方法的理解

① 也叫作构造器，严格来讲，构造方法不是方法。

② 构造方法要求和类名相同，没有返回值类型，也没有void.

③可以有return，表示方法的结束，不能返回值（不推荐），除非要写一个业务逻辑

作用：

①完成对象的初始化工作

②每个Java的类都至少要有一个构造方法，如果不写构造方法，编译器会提供一个没有任何参数和语句的构造方法，Student（）{}，如果写了构造方法，那么编译器不会再提供默认的构造方法。所以一旦自己写了构造方法，必须要写对，写正确。

③ 一个类可以定义多个构造方法（构造方法的重载）

④一般情况下都会写一个无参的构造方法。这是好的变成习惯。

public class Student {
    Student(){
        
    }
}

构造的作用就是完成对象的初始化工作，在这里，如果把Student（）删掉

public class Student {
    private String name;
    private String gender;
    private int age;
    Student(){
        name="张三";
        gender="男";
        age=19;
    }
    public void showInfo(){
        System.out.println("姓名:"+name+"\t性别:"+gender+"\t年龄:"+age);
    }
}

那么在这里输出的默认值就不会是张三男 19

public class TestStudent {
    public static void main(String[] args) {
        //new Student()实际上就是在调用构造方法
        Student student1=new Student();
        student1.showInfo();
    }
}

（2）一个类可以定义多个构造方法（构造方法的重载）

    private String name;
    private String gender;
    private int age;
    
    public Student(){
        System.out.println("这是无参数的构造方法!");
    }
    public Student(int x){
        System.out.println("这是有参数的构造方法!");
    }
    public Student(String  x){
        System.out.println("这是有参数的构造方法!");
    }

（3）构造方法的调用

① 如果是在其他类中，则通过new的方式来调用构造方法

②如果在自己的类中，可以调用别的构造方法，但也仅限于构造方法间的调用，且必须写在第一行，不允许相互调用。

    public Student(){
        this(12);
        System.out.println("这是无参数的构造方法!");
    }
    public Student(int x){
        this("123");
        System.out.println("这是有参数的构造方法!");
    }
    public Student(String  x){
        System.out.println("这是有参数的构造方法!");
    }

（4）构造方法的应用

那么既然构造方法也可以传值，是不是那些setter和getter都没用了？

非也，构造方法只是用来做初始化，之后还可能变化。

public class Dog_Test {
    public static void main(String[] args) {
        Dog dog1=new Dog("red",12);
        dog1.showInfo();
        dog1.setAge(13);
        dog1.setColor("blue");
        dog1.showInfo();
    }
}

注意：一般情况下都会写一个无参的构造方法。这是好的变成习惯。

    public Dog(){ //无参
        
    };
    public Dog(String color, int age){   //有参数
        this.color=color;
        this.age=age;

    }

（5）快捷生成构造 alt+insert

（6）对象作为方法参数

讲对象作为方法参数：将所有属性进行封装，传递给另外一个类的方法，需要那些属性，获取那些属性。

老师

public class Teacher {
    public void sign(Student student){  //传的是整个对象，可以到到这个人的 所有信息
        System.out.println("老师点名！");
        if (student.getGender().equals("男")){
            System.out.println(student.getName()+"到");
        } else if (student.getGender().equals("女")) {
            System.out.println(student.getName()+"有");
        }
    }
}

学生

public class Student {
    String name;
    int age;
    String gender;

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

    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 getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    public void showInfo(){
        System.out.println();
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Student student1=new Student("李清照",12,"女");
        Teacher teacher=new Teacher();
        teacher.sign(student1);
        Student student2=new Student("杜甫",121,"男");
        teacher.sign(student2);
    }
}

（7）方法返回类型是一个对象类型

Monitor

public class Monitor {
    public Student register(){  //学生对象
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入姓名：");
        String name = scanner.next();

        System.out.println("请输入性别：");
        String gender = scanner.next();

        System.out.println("请输入年龄：");
        int age = scanner.nextInt();
 
        return new Student(name, age, gender);  // 返回的是一个对象
    }
}

public class Test {
    public static void main(String[] args) {
        Monitor monitor=new Monitor();  //测试的时候可以直接用Monitor，因为monitor返回的是对象student
        Student student1=monitor.register();
        Teacher teacher=new Teacher();
        teacher.sign(student1);
        Student student2=monitor.register();
        teacher.sign(student2);
    }
}

7、对象数组的方式

原来的方式调用很麻烦，每个对象都要用一行代码调用。

public class Test {
    public static void main(String[] args) {
        // 麻烦，需要调用很多次，建议用数组
        Student student=new Student("李清照","女");
        Student student1=new Student("李白","男");
        Student student2=new Student("杜甫","男");

        Teacher teacher=new Teacher();

        teacher.sign(student);
        teacher.sign(student1);
        teacher.sign(student2);

    }
}

原来的老师类

public class Teacher {
    public void sign(Student student){
        String gender = student.getGender();
        if (gender.equals("男")){
            System.out.println(student.getName()+"到！");
        } else if (gender.equals("女")) {
            System.out.println(student.getName()+"有！");
        }else{
            System.out.println("性别不对，没有"+gender);
        }

    }
}

看起来很麻烦，那么我们可以改成数组。

public class Teacher {
    public void sign(Student[] students){
        for (Student student : students) {
            String gender = student.getGender();
            if (gender.equals("男")){
                System.out.println(student.getName()+"到！");
            } else if (gender.equals("女")) {
                System.out.println(student.getName()+"有！");
            }else{
                System.out.println("性别不对，没有"+gender);
            }
        }
    }
}

测试

public class Test {
    public static void main(String[] args) {
        // 麻烦，需要调用很多次，建议用数组
        Teacher teacher=new Teacher();
        // 创建学生对象数组
        Student[] students=new Student[3];
        students[0]=new Student("李清照","女");
        students[1]=new Student("李白","男");
        students[2]=new Student("杜甫","男");
        teacher.sign(students);
    }
}