面向对象

JAVA（面向对象）

面向对象：

把整个需求按照特点，功能划分，将这些存在共性的部分封装成类，类实例化之后才是对象，让对象解决问题。

例子：送一个人一个物品，找个店，买个东西，不管是店家还是物品都是现实存在的，这个店家和物品都可以是对象，

所有的类都是数据类型，都是引用数据类型，引用数据类型的默认值为null

成员变量：变量声明在类里

在JAVA中，万事万物皆是对象。

在Linux中，万事万物皆是文件。

数据类型：

面向过程：

找到原材料，自己加工，自己做。

分析出实现需求需要的步骤，通过一些方法一步一步实现，

面向对象特征：

封装
继承
多态
（抽象）

封装：

2个方面：代码层面，思想层面

创建实例化对象：类名对象名=new 类名();

对象名叫引用，指向一个内存空间，存放的空间叫堆；

有了new可理解为就不是null，就有地址

赋值时，除了String，其余数据类型都需要new

证明：栈中对象名存的地址

运行结果：包名.类名@地址

STATIC:

用来修饰成员变量
static只能修饰成员变量，无法修饰局部变量
一旦被static修饰之后，变量即为静态变量，可以使用类名.属性名的形式对属性进行操作。
用来修饰成员方法
成员方法一旦成为静态，在方法中所调用的方法或者变量也必须是静态的
用来修饰代码块

成员方法：

访问权限修饰符

public :共用的，在同一个工程中，都能用（类，属性，方法，构造器）
protected：受保护的，可以跨包，如果跨包，必须是他的子类（属性，方法，构造器）
默认的：友好的，当前包下可以访问（类，属性，方法，构造器）
private：私有的，只有在当前类可以用（属性，方法，构造器）

Java.lang下的所有类不需要显示导包

返回类型：

void：无返回值(可以有return;)
基本数据类型
表达式，String

set()：标识符

标识符命名规则：字母，数字，下划线，美元符号，数字不能开头
类名：大驼峰
属性名，方法名：小驼峰

{}：方法体

()：可以传参数，参数可以有多个，中间用“，”隔开，需要明确数据类型

括号里的参数，叫形式参数，简称形参
在调用方法时，传入的参数，叫实际参数，简称实参

方法调用：

对象.方法名
方法只能调用方法，不能声明方法
一个static方法调用一个非static方法，只能创建对象
自己调用自己叫递归，递归的问题：StaticOverflowError 栈溢出（内存溢出）

成员方法案例:

class  Che{
    String brand;
    String color;
    int len;
    public  void set(String brand,String color,int len){
        this.brand=brand;
        this.color=color;
        this.len=len;
    }
    public String  toStrings(){
        return brand+" "+color+" "+len;
    }
}
public class Test_1 {
    public static void main(String[] args) {
    Che c=new Che();
    c.set("a","blue",1);
    System.out.println(c);


    }
}

斐波那契数列：

1.递归

    public static void main(String[] args) {
        //斐波那契数列
        for(i=1;i<20;i++){
            System.out.print(fat(i) +" ");
        }
    }
    static  int fat(int i){
        if(i==1||i==2)
            return 1;
        else{
            return fat(i-1)+fat(i-2);
        }
    }

2.for循环的2种方式

        //斐波那契数列
        int f1=1,f2=1,f3;
        int i,j;
	for(i=0;i<20;i++){
			f3=f1+f2;
			System.out.print(f3+" ");
			f1=f2;
			f2=f3;
    }

        int f1=1,f2=1,f3;
        int i,j;
for(i=1;i<20;i++){
		System.out.print(f1+" "+f2+" ");
		if(i%2==0)
		    System.out.print();
		f1=f1+f2;
		f2=f1+f2;
	}

求阶乘：

public static void main(String[] args) {
        //求阶乘,负数没有阶乘
        System.out.println(x(4));
    }
    static  int x(int x){
        if(x>0){
            return x*x(x-1);
        }else{
           return  0;
        }
    }

方法的重载：

方法名相同

参数不同才能构成方法不同：参数类型，个数，顺序，与访问权限无关，发生在同一个类

案例：

    static  int  sum(int a,int b,int c){
        return  Math.max((Math.max(a,b)),(Math.max(b,c)));
    }
    static  int  sum(int a,int b){
        return Math.max(a,b);
    }

    public static void main(String[] args) {
        System.out.println(sum(1, 2));
        System.out.println(sum(1, 2, 3));
    }

不定长参数：

参数列表中最多有一个不定长参数
不定长参数必须在最后

static  int sums(int ... arr){
        //不定长参数
        int r=0;
        for (int i : arr) {
            r+=i;
        }
        return  r;
    }
static void x(double a,int ... arr){
}
    public static void main(String[] args) {
        System.out.println(sums(1,2,3,4,5,6,7,4));

    }

构造方法：

语法：访问权限修饰符类名（参数列表）{}

构造器特点：

java在new对象的时候，先看对象所对应的类有没有构造器，如果没有，则无法创建对象
每个类会有一个的默认的无参的构造器
在对象被实例化时调用了构造器
类名对象名=new 构造器
创建对象是通过构造器创建的
如果一个类中显示了声明了一个构造器，默认的无参构造器就失效
可以重载

深复制与浅复制

posted @ 2022-07-18 11:56 一只神秘的猫阅读(45) 评论(0) 收藏举报

刷新页面返回顶部

一只神秘的猫