Java面向对象OOP（上）

最新推荐文章于 2024-07-17 15:37:07 发布

Lacrimosa&L

最新推荐文章于 2024-07-17 15:37:07 发布

阅读量238

点赞数

分类专栏： Java基础文章标签： java 类面向对象编程

本文链接：https://blog.csdn.net/AC_872767407/article/details/112656482

版权

Java基础专栏收录该内容

40 篇文章 1 订阅

订阅专栏

文章目录

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 方法的重载（overload）

概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
示例：

我们自己写的重载方法

public class PrintStream {
	//普通方法
	public static void print(int i) {……}
	public static void print(float f) {……}
	public static void print(String s) {……}
	
	//main方法
	public static void main(String[] args) {
		print(3);
		print(1.2f);
		print("hello!");
	} 
}

另外，System.out.println()方法就是典型的重载方法，其内部的声明形式如下

public void println(byte x)
public void println(short x)
public void println(int x)
public void println(long x)
public void println(float x)
public void println(double x)
public void println(char x)
public void println(double x)
public void println()
……

4 可变个数形参

当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个，2个等等
可变个数形参在方法的形参中，最多只能声明一个可变形参，且必须声明在末尾

1 可变个数形参

结果：
show(String ... strs)
hello
BB
CC
show(String ... strs)
hello
BB
CC

test.show(new String[]{"hello","BB","CC"});
test.show("hello","BB","CC");

public void show(String ... strs){
		System.out.println("show(String ... strs)");
		
		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
}

2 字符串数组

结果：
show(String [] strs)
hello
BB
CC
show(String [] strs)
null
null
null

test.show(new String[]{"hello","BB","CC"});
test.show(new String[3]);
test.show("hello","BB","CC");      //ERROR 实参和形参列表长度不同

public void show(String[] strs){
		System.out.println("show(String ... strs)");

		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
}

5 值传递

值传递机制：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

面试题1
在这里插入图片描述

解法1( `System.exit(0); `      终止当前正在运行的 Java 虚拟机)
a *= 10;
b *= 20;
System.out.println(a);
System.out.println(b);
System.exit(0);

解法2：重写方法？

面试题2
在这里插入图片描述

面试题3(乐视)

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);
    }

 */

4、面向对象（上）总结（概念）

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

5、变量与方法

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

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