Java面向对象OOP（上）

文章目录

1、初识面向对象

面向过程和面向对象
面向对象OOP本质：以类的方式组织代码，以对象的形式封装（组织）数据。
抽象
三大特性：
封装
继承
多态

2、方法回顾和加深

1方法的定义

修饰符
返回类型
break和return的区别：

break 跳出switch，结束循环

return 结束方法，返回一个结果
方法名：驼峰命名、见名知意
参数列表：（参数类型, 参数名）… 可以有多个
异常抛出：如数组下表越界

break	跳出switch，结束循环
return	结束方法，返回一个结果

package OOP.OOP1;

//Demo1  类
public class Demo1 {
    
    
    //main  方法
    public static void main(String[] args) {
    
    
        //
    }

    /*
    修饰符         返回类型    方法名(...){
        //方法体
        return  返回值;
    }
     */

    public String sayHello(){
    
    
        return "helloworld";
    }
    public int max(int a1,int b1){
    
    
        return a1 > b1?a1:b1;
    }

}

2方法的调用

静态方法
非静态方法
形参和实参
值传递和引用传递
this关键字

3、对象的创建分析

使用new关键字创建对象

1、使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
2、类中的构造器也称为构造方法，是在创建对象的时候必须要调用的。构造器有以下两个特点：
1）必须和类的名字相同
2）必须没有返回类型，也不能写void

package OOP.OOP1;

public class Demo2 {
    
    
    public static void main(String[] args) {
    
    
        //实例化这个类
        //对象类型   对象名  =  对象值；
        Student student = new Student();
        int result = add(1,2);
        System.out.println(result);
    }
    public static int add(int a,int b){
    
    
        return a+b;
    }
}

package OOP.OOP1;

//学生类
public class Student {
    
    

    //非静态方法
    public void say(){
    
    
        System.out.println("学生说话了");
    }
    //静态方法：和类一起加载的（创建对象前就已经存在）
    public static void a(){
    
    
        //b();     error
    }
    //非静态方法：类实例化之后才存在
    public void b(){
    
    
        a();
    }

}

构造器必须掌握

package OOP.OOP2;
public class Person {
    
    
    //一个类即使什么都不写，它也会存在一个方法
    //显式地定义构造器
    String name;
  
    //实例化初始值
    //1、使用new关键字，必须要有构造器
    //2、用来初始化值
    public Person(){
    
    
        this.name = "xiaosan";
    }

    //有参构造：一旦定义了有参构造，无参就必须显式定义
    public Person(String name){
    
    
        this.name = name;
    }

    //alt + insert 自动生成构造函数的快捷键
}

/*
public static void main(String[] args) {
        //new  实例化了一个对象
        Person person = new Person("xiaosi");

        System.out.println(person.name);
        //Person(xiaosi);
    }

    构造器：
        1、和类名相同
        2、没有返回值
    作用：
        1、new本质是在调用构造方法
        2、初始化对象的值
    注意点：
        1、定义有参构造后，如果想使用无参构造，必须显式地定义一个无参的构造

        Alt + Iesert

        this.name = name;
        前一个name指向当前对象     后一个是传递过来的参数
 */

一个student类

package OOP.OOP2;

//学生类
public class student {
    
    

    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
    
    
        System.out.println(this.name + "在学习");
    }
}
/*
public static void main(String[] args) {

        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //xiaoming对象就是一个student类的具体实例！
        student xiaoming = new student();
        student xiaohong = new student();

        xiaoming.name = "小明";
        xiaoming.age = 3;

        System.out.println(xiaoming.name);
    }

 */

面向对象（上）总结

类与对象
类是一个模板，对象是一个具体的实例。
方法
定义、调用
对象的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈—>堆
属性：也叫字段filed 成员变量
默认初始化：
数字：0
char:u0000
boolean:false
引用：null
修饰符属性类型属性名 = 属性值！
对象的创建和使用
使用new关键字创造对象，构造器 Person xiaosan = new Person();
对象的属性 xiaosan.name
对象的方法 xiaosan.sleep()
类：
静态的属性属性
动态的行为方法

变量与方法

成员变量与局部变量的区别有哪些？

参数	成员变量	局部变量
作用域	针对整个类有效	只在某个范围内有效（一般就是方法，语句体内）
存储位置	随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。	在方法被调用，或者语句被执行的时候存在，存储在栈内存中。当方法调用完，或者语句结束后，就自动释放。
生命周期	随着对象的创建而存在，随着对象的消失而消失	当方法调用完，或者语句结束后，就自动释放。
初始值	有默认初始值	没有默认初始值，使用前必须赋值

一个类的构造方法的作用是什么？若一个类没有声明构造方法，改程序能正确执行吗？为什么？

主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。

静态变量和实例变量区别

静态变量：静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。
实例变量：每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。

静态变量和普通变量区别

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化。

静态方法和实例方法有何不同？

静态方法和实例方法的区别主要体现在两个方面：

在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制

在一个静态方法内调用一个非静态成员为什么是非法的？

由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。