java面向对象

面向对象 oop Object Oriented Programming

递归 他是一种思想 递归思想

也就是自己调用自己，类本身调用自己 ，可以用于小计算昂，如果调用的次数过多就容易蹦，那就要想一种算法去解决了。 例如阶乘 :

public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 5！ 5*4*3*2*1
		System.out.println(f(1));
	}
	
	public static int f (int n ){
		if(n==1){
			return 1;
		}else{
			return n*f(n-1);    // 这里就可以理解为递归
		}
		
	}

数组

int[] arr 首选 也可以 int arr[]次选 为了让c和c++基础的更快上手 声明 dateType[] arr = new dateType[长度]; 声明 + 创造

在我们没有给数组每个元素都赋值时，他们会有一个默认的初始化值 例如 int默认0，String默认null

  1. 数组是相同数据类型(数据类型可以为任意类型)的有序集合数组也是对象。
  2. 数组元素相当于对象的成员变量。
  3. 数组长度的确定的，不可变的。如果越界，则报:ArraylndexOutofBounds

import java.util.Arrays

​ toString，可以用来打印数组 例如 Arrays.toString(arr)

内存分析 堆栈空间 方法区

基本数据类型、局部变量都是存放在栈内存中的，用完就消失。
new创建的实例化对象及数组，是存放在堆内存中的，用完之后靠垃圾回收机制不定期自动消除。

  • 堆

    1. 存放new的对象和数组 ，可以被所有的线程共享

    2. 不会存放别的对象引用

  • 栈

    a.存放基本变量类型（会包含这个基本类型的具体数值）

    b.引用对象的变量（会存放这个引用在堆里面的具体地址）

  • 方法区

​ a.可以被所有的线程共享

​ b,包含了所有的class和static变量

栈：

函数中定义的基本类型变量，对象的引用变量都在函数的栈内存中分配。
栈内存特点，数数据一执行完毕，变量会立即释放，节约内存空间。
栈内存中的数据，没有默认初始化值，需要手动设置。

堆：

堆内存用来存放new创建的对象和数组。
堆内存中所有的实体都有内存地址值。
堆内存中的实体是用来封装数据的，这些数据都有默认初始化值。
堆内存中的实体不再被指向时，JVM启动垃圾回收机制，自动清除，这也是JAVA优于C++的表现之一（C++中需要程序员手动清除）。

内存空间，堆栈

注：

什么是局部变量：定义在函数中的变量、定义在函数中的参数上的变量、定义在for循环内部的变量

面向对象编程：本质 --- ''以类的方式组织代码，以对象的方式组织(封装)数据''

  • static static static 修饰符 静态方法和非静态方法;已存在的调用一个未存在的，肯定会报错

  • 加了static 就是静态方法 ，我们可以直接调用。有static修饰符的方法是跟类一起加载的，是已经存在的。

  • 没加static就是非静态方法，我们需要实例化这个类， 例如有个Student类，里面定义了一个say方法，我们要在main方法中使用他， 就要 Student s = new Student(); s.say(); 而没有加static修饰符的方法，要进行类实例化，他才存在。

值传递

public static void main( String[ ] args) {
		int a = 1;
		System.out.println(a);//1
		类名.change(a);
		System.out.println(a);//1
    //因为 这里的a调用方法  ，进行的是值传递，改变的是形参而不是实参
	}//返回值为空

public static void change(int a) {
		a = 10;
	}

引用传递

​ 他是通过传递对象，是同一个对象，所以改变其属性改变的也是同一个对象的属性值。

构造器：

  1. 构造器与类同名
  2. 没有返回值
  3. 类默认都有一个无参构造器
  4. 如果有有参构造那么无参构造就不能调用了

作用：

  1. new 本质就是在调用构造方法
  2. 初始化对象的值

面向对象：

1。类与对象
类是一个模板:抽象，对象是一个具体的实例
2.方法
定义、调用!
3．对应的引用
引用类型:基本类型(8)
对象是通过引用来操作的:栈--->堆
4．属性:字段FieLd 成员变量
默认初始化:
数字:0 0.0 char : u0000 boolean:false 引用: null
修饰符属性类型属性名=属性值!
5．对象的创建和使用
-必须使用new关键字创造对象，构造器Person mao= new Person( );
-对象的属性mao.name
-对象的方法mao.sleep()
6．类:
静态的属性 属性
动态的行为 方法

方法的重载：就是使用相同的方法名再次编写一个方法，但是参数不同

封装： (属性私有（用private修饰属性），get/set)

作用：

  1. 提高程序的安全性，保护数据

  2. 隐藏代码的实现细节

  3. 统一接口

  4. 系统可维护性增加了

继承： 所有的类都默认继承object类

-=-=子类(派生类) 父类(基类)-=-=
子类将父类的东西继承过来，能直接用。
extends关键字
Java中类只有单继承，没有多继承。一个儿子只能有一个父亲，但是一个父亲可以有多个儿子。

public protected default private
私有的东西是无法被继承的。
关键字 super 调用父类的东西 可以把他当做该子类的一个父类可直接调用. super()
super() 默认会在子类构造器的第一行，他要首先调用
super的注意点： 在子类构造器中使用，若子类要写无参构造首先父类一定要有
super和this不能同时调用构造方法！他只有在extends条件下才能使用

子类的构造器中会默认使用super调用父类的无参构造，

若父类没有无参构造只有有参构造，那么就需要通过super(arg)来调用父类的有参构造

super vs this

代表的对象不同:
this:本身调用者这个对象 super:代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件下才可以使用构造方法
this():本类的构造 super():父类的构造!

重写Override：重写都是方法的重写，和属性是无关的 。 他首先需要有继承的关系，是子类重写父类的方法。方法一致，但是方法体的内容是不同的

​ B是父亲，父亲可以生一个儿子，儿子不可以生父亲

A extends B   
// 重写的方法，他的修饰符只能是public
// 下面是在类中的test方法 是用static修饰的时候，他是静态方法
// 方法的调用只和左边，定义的数据类型有关
A a = new A();
a.test(); //A
//父类的引用指向了子类
B b = new A();
b.test(); //B
//====================================================
//当子类中方法重写后
A a = new A();
a.test(); //A
//父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.test(); //A

image-20220301213329414

多态：

例如 A extends B
B是父亲，父亲可以生一个儿子，儿子不可以生父亲， 所以
A a = new A(); B b = new A();
方法的调用只和左边，定义的数据类型有关

多态需要注意的点：

多态注意事项:
1．多态是方法的多态，属性没有多态
2．父类和子类，有联系 类型转换异常——ClassCastException !
3．存在条件:继承关系，方法需要重写，父类引用指向子类对象!
Father f = new Son();

  1. static 方法，属于类，它不属于实例
  2. final常量;.
  3. private方法;
    这些都是不可以进行重写的

instanceof 关键字 就是判断A与B是否有关系 A instanceof B
类型转换：高转低——强制类型转换；低转高——直接转。
低转高可能会丢失自己本身的一些方法
也就是儿子找爸爸要东西比爸爸找儿子要东西简单。。。。（自己的理解昂、。）
类型转换的作用：方便方法的调用。。

static 静态代码

他是与类一块儿加载的。

{
    //第二个执行
	//用于加载一些初始化的东西，可以用来赋初始值
    //匿名代码块
}		
static{
    //最开始执行，并且整个程序只执行一次
	//，里面的东西可以直接调用
    //静态代码块
}
public ClassA(){
    //第三个执行
    //构造方法
}
静态导入包！！！牛逼======================================

就是你在使用一个包中的方法或者属性的时候，你每次都需要通过 "." 来获取
但是有了static 就简单了， 可以在修饰后直接使用

//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
	public static void main( String[] args) {
		system.out.println(random());
		system.out.println(PI);
	}
}

final 用final修饰的属性和值不能再次进行修改，如果用来修饰类，那么它将不能被继承，也就是说他已经断子绝孙了

abstract 抽象类 单继承 他就是一个约束~ 提高开发效率

用abstract修饰的类就叫做抽象类，然后里面的方法也用abstract修饰
但是他只是做了一个约束，就是讲类的大概结构，抽象方法只能在抽象类中，而抽象类中可以写普通方法
具体的实现方法，需要别人来帮我们实现。没有方法体|
他只能在被子类继承后，使用重写将抽象类方法实现。

接口：interface 重点重点-----------也是一个约束------------

接口中的所有定义的方法都是抽象的 它本身就是被 public abstract 所修饰
我们以后写接口中的方法 可以直接通过 void method(); 里面可以写形参
一个实现类可以通过 implement 实现多个接口 。 利用接口实现（多继承）
当然接口里面也可以定义一些常量，但是一般不会这么做。
常量：public static final 所修饰的
接口不能被实例化 ， 因为接口中没有构造方法
接口中被实现里面的方法必须要被重写！

内部类：

成员内部类

例如 有一个外部类 Class Outer 然后我们在Outer类中定义一个类 叫Class Inner 那么inner就是一个内部类
然后我们要在主程序中new一个内部类就要通过outer outer.new inner = outer.New Inner();
我们可以通过内部类访问到外部类的私有方法和属性 如果static修饰的就叫做静态成员内部类（要记住被static所修饰的都是跟类一起加载的）

局部内部类

被定义在局部作用域内的类，例如被定义在方法内的类，这就叫做局部内部类

匿名类，匿名对象

例如有一个类叫做 People，里面有一个方法叫做sing()。我们可以通过 new People(),sing(); 也可以使用这个方法。
而且 这个new出来的people也不会被实例保存为变量

规范： 高聚和，低耦合

一个项目中应该只有一个main方法。

posted @   没有烦恼的猫猫  阅读(11)  评论(0)  编辑  收藏  举报
相关博文：
·  Java基础
·  注解和反射
·  java基础
·  java面向对象
·  JAVA之面向对象进阶
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~
点击右上角即可分享
微信分享提示
SQL AI 助手