Java基础

数组:

动态分配方式一:
数据类型 数组名[] = new 数据类型[大小]
int a[] =new int[8];
动态分配方式二:
double scoures[];
scours = new double[35];
静态分配方式:

数据类型 数组名[] = {元素值,元素值……}


方法:

方法重载(OverLoad):

Java允许同一个类中,多个同名方法的存在,但要求形参列表不一致;

可变方法:

java允许将同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法。

 基本语法:访问修饰符 返回类型 方法名(数据类型...形参名){}
          public int sum (int...nums){}
          int...  表示接受的是可变参数。类型是int,即可以接收多个int(0~多)

构造器

基本语法:

[修饰符] 方法名(形参列表){方法体};

主要作用:

是完成对新对象的初始化(而不是创建对象)。

如:per p = new per();

此时p指向一个对象,对象的空间已经有了,对象里面的值的初始化就由构造器来完成。

特点:
  1. 方法名与类名相同;
  2. 没有返回值;
  3. 在创建对象时,系统会自动的调用该类的构造器完成对对象的初始化。
说明:
  1. 构造器的修饰符可以默认;
  2. 构造器没有返回值;
  3. 方法名和类名字必须一样;
  4. 参数列表和成员方法一样的规则;
  5. 构造器的调用系统完成。
例子:

在创建人类的对象时,就直接指定这个对象的年龄和姓名。

//编写一个main方法
public static void main(String[] args) {
    //当我们new一个对象时,直接通过构造器指定名字和年龄
    ew Person("smith",80)
}
//执行结果:输出"构造器被调用~~完成对象的初始化",证明调用了构造器方法。
========================================================================
class Person{
    Sustem.out.pringtin("构造器被调用~~完成对象的初始化")
    String name;
    int age;
    /*
        构造器解读:
        1、构造器没有返回值,也不能写void;
        2、构造器的名称和类Person一样
        3、(String pName, int pAge)是构造器形参列表,规则和成员方法一样。
    */
    public Person(String pName, int pAge){
    name = pName;
    age = pAge;
    }
}

访问修饰符:

java提供四种访问修饰符号控制方法和属性(成员变量)的访问权限(范围):

  1. public(公共的):
    对外公开;
    一个java文件中只可以有一个public修饰的类,并且类名需要和文件名相同
  2. protected(受保护的):
    对子类和同一包中的类公开;
  3. default(默认的):
    默认修饰符,没有修饰符号,向同一个包的类公开;
  4. private(私有的):
    只有类本身可以访问,不对外公开。

封装:

封装的实现步骤(三步)
  1. 将属性进行私有化private 【不能直接修改属性】
  2. 提供一个公共的(public)set方法,用于对属性判断并赋值
public void setXxx(类型 参数名){                //Xxx表示某个属性
    //加入数据验证的业务逻辑
    属性 = 参数名;
}
  1. 提供一个公共的(public)get方法,用于获取属性的值
public 数据类型 getXxx(){        //权限判断,Xxx某个属性
    return xx;
}

继承:

继承可以解决代码复用,让我们的编程更加接近人类思维,当多个类存在相同的属性(变量)和方法时,可以从这些类中抽出抽象的父类,在父类中定义这些相同的属性和方法,所有的子类补血药重新定义这些属性和方法,只需要通过extends来声明继承父类即可。

基本语法:

calss 子类 extend 父类{}

说明:
  1. 子类就会自动拥有父类定义的属性和方法;
  2. 父类又叫超类,基类;
  3. 子类又叫派生类。
注意:
  1. 子类继承了所有的属性和方法,但是私有属性和方法不能在子类中直接访问,要通过公共的方法去访问;
  2. 子类必须调用父类的构造器,完成父类的初始化;
  3. 当创建子类对象时,不管使用子类哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作,否则,编译不会通过;
  4. 如果希望指定去调用父类的某个构造器,则显示的调用一下;
  5. super在使用时,需要放在构造器第一行;
  6. super()和this()都只能放在构造器第一行,因此这两个方法不能共存一个构造器;
  7. java所有类都是Object的子类,Object是所有类的基类;
  8. 父类构造器的调用不限于直接父类!将一直往上追溯到Object类(顶级父类);
  9. 子类最多只能继承一个父类(指直接继承),即java中是单继承机制;如何让A类继承B类和C类?可以先A继承B,然后B再继承C;
  10. 不能滥用继承,子类和父类之间必须满足is-a的逻辑关系;
如:Music extend Person                 //不合理;
    Cat extend Animal                 //合理

super关键字:

super代表父类的引用,用于访问父类的属性、方法、构造器

基本语法:
  1. 访问父类的属性,但不能访问父类的private属性
    super.属性名;

  2. 访问父类的方法,不能访问父类的private方法
    super.方法名(参数列表);

  3. 访问父类的构造器
    super(参数列表);在能放在构造器的第一句,只能出现一句!

super带来的便利:
  1. 调用父类的构造器的好处(分工明确,父类属性由父类初始化,子类属性由子类初始化)
  2. 当子类中有和父类中的成员(属性和方法)重名时,为了访问父类的成员,必须通过super。如果没有重名,使用super、this、直接访问效果是一样的。
  3. super的访问不限于直接父类,如果爷爷类和本类中有同名的成员,也可以使用super去访问爷爷类的成员;如果多个基类中都有同名的成员,使用super访问遵循就近原则。A->B->C

方法重写/覆盖:

基本介绍:

方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数都一样,那么我们就说子类的这个方法覆盖了父类的哪个方法。

class Animal{
    public void cry(){
        System.out.print("动物叫唤");
    }
}

class Dog extend Animal{
    public void cry(){
        System.out.print("小狗汪汪叫");
    }
}
注意事项:
  1. 子类的方法的参数、方法名称,要和父类方法的参数,方法名称完全一样。
  2. 子类方法的返回类型和父类方法返回类型一样,或者是父类返回类型的子类
    比如: 父类 返回类型是 Obje,子类返回方法类型是String
public Object getInfo(){}
public String getInfo(){}
  1. 子类方法不能缩小父类方法的访问权限
void sayOK(){}
public void sayOK(){}

多态:

我们通过不同的参数个数去调用sum方法,就回去调用不同的sum方法
因此对sum方法来说,就是多种状态的体现

A a = new A();
System.out.print(a.sum(10,30));
System.out.print(a.sum(10,30,50));
 main方法:
Master tom = new Master("汤姆");
Dog dog = new Dog("大黄");
Bone bone = new Bone("大棒骨");
tom.feed(dog,bone);

Cat cat = new Cat("小花猫");
Fish fish = new ("黄花鱼");
tom.feed(cat,fish);

===========================================================================

//主人给 小狗 喂食 大棒骨
public void feed(Dog dog,Bone bone){
    System.out.print("主人" + name + "给" + dog.getName + "吃" + bone.getName);
}
//主人给 小花猫 喂食 黄花鱼
public void feed(Cat cat,Fish fish){
    System.out.print("主人" + name + "给" + cat.getName + "吃" + fish.getName);
}

/*
    使用多态机制,可以统一的管理主人喂食的问题
    animal编译类型是Animal,可以指向(接收)Animal子类的对象
    food编译类型是Food,可以指向(接收)Food子类的对象
*/
public void feed(Animal animal,Food food){
    System.out.print("主人" + name + "给" + animal.getName + "吃" + food.getName);
}
向上转型:

(把子类提高到父类的层次)如:Animal animal = new Cat();
1. 本质:
父类的引用指向了子类的对象
2. 语法:
父类类型 引用名 = new 子类类型();
3. 特点:
编译类型看左边,运行类型看右边。
可以调用父类中的所有成员(需遵守访问权限),不能调用子类中特有成员;最终运行效果看子类的具体实现!

向下转型:
  1. 语法:子类类型 引用名 = (子类类型) 父类引用;
    Cat cat = (Cat) animal;
  2. 只能强转父类的引用,不能强转父类的对象;
  3. 要求父类的引用必须指向的是当前目标类型的对象;
  4. 可以调用子类类型中所有的成员。

属性重写:

class Base{
    int count = 10;
}
class Sub extends Base{
    int count = 20;
}

==运算符

  1. ==既可以判断基本类型,又可以判断引用类型;
  2. ==如果判断基本类型,判断的值是否相等。示例:int i = 10;double d = 10.0;
  3. ==如果判断引用类型,判断的是地址是否相等,即判定是不是同一个对象。
例子:
A obj1 = new A();
A obj2 = new A();
A obj3 = obj1;                //引用赋值,其实给的是地址

equals方法:

  1. equals是Object类中方法,只能判断引用类型。
  2. 默认判断的是地址是否相等,子类中往往重写该方法,用于判断内容是否相等。

hashCode方法:

  1. 提高具有哈希结构的容器的效率;
  2. 两个引用,如果指向的是同一个对象,则哈希值肯定是一样的;
  3. 两个引用,如果指向的是不同对象,则哈希值是不一样的;
  4. 哈希值主要根据地址号来的,不能完全将哈希值等价于地址;
  5. 后面在集合中,hashCode如果需要的话,也会重写。

toString方法:

基本介绍:
  1. 默认返回:全类名+@+哈希值的十六进制,[查看Object的toString方法];子类往往重写toString方法,用于返回对象的属性信息。
  2. 重写toString方法,打印对象或者拼接对象时,都会自动调用该对象的toString形式;
  3. 当直接输出一个对象时,toString方法会被默认的调用。

finalize方法:

  • 当对象被回收时,系统自动调用该对象的finalize方法,子类可以重写该方法,做一些释放资源的操作。
  • 什么时候被回收:当某个对象没有任何引用时,则jvm就认为这个对象是一个垃圾对象,就会使用垃圾回收机制来销毁该对象,在销毁该对象前,会先调用finalize方法。
  • 垃圾回收机制的调用,是由系统来决定,也可以通过System.gc()主动出发垃圾回收机制。
Car bmw = new Car("宝马");
bmw = null;  //这时,Car对象就是一个垃圾对象,垃圾回收器就会回收(销毁)对象
                //在销毁对象前,会调用该对象的finalize方法,
                //程序员就可以在这个方法中写自己的业务逻辑代码(如释放资源、数据库连接或者打开的文件……)
                //如果程序员不重写finalize方法,那么就会调用Object类的finalize方法,即默认处理;
                //如果程序员重写了finalize方法,就可以实现自己的逻辑
当bmw = null执行时,bmw指向Car的线就断了,此时,Car对象就成了一个垃圾对象
创作不易!转载请注明作者及文章链接或作者博客链接——
- 作者:pidanxia
- 链接:https://pidanxia.ink
(链接可为:**文章链接**或者**作者博客链接**)

评论

  1. Bob
    7 月前
    2023-9-10 17:10:27

    哈哈,很好

    • 博主
      Bob
      7 月前
      2023-9-12 11:13:15

      感谢认可哈哈🌹

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
下一篇