本文介绍: 以上就是本篇文章的全部内容,如果你觉得本文对你有所帮助的话,那不妨点个小小的赞哦!(比心)

🎇个人主页Ice_Sugar_7
🎇所属专栏快来卷Java啦
🎇欢迎点赞收藏加关注哦!

🍉匿名对象

特点:使用new来创建对象,但是不声明对象的引用变量
缺点:只能使用一次,不能重复使用

    System.out.println(new Student("sugar","male",21));

而数组也是一个对象,所以我们也可以采用匿名对象来打印数组:

    for (int i:array1) {
        System.out.print(i + " ");
    }
    System.out.println(" ");
    for(int i:new int[]{2,3,4,5,6}) {
        System.out.print(i + " ");
    }

在这里插入图片描述


🍉关键字static

之前在Student类中定义的成员变量,每个对象中都会包含一份(称之为实例变量)
而被static修饰的成员,称为静态成员,也可以称为类成员,它不属于某个具体的对象,而是所有对象共享的

(注意:static不可以修饰局部变量,因为局部变量不属于类)

🍌static修饰成员变量

特性:
●存储在方法区当中,不存储在某个对象的空间中。不属于某个具体的对象,是类的属性,所有对象共享的
●既可以通过对象访问,也可以通过类名访问,但一般更推荐使用类名访问
●生命周期伴随类的一生(就是随类的加载而创建,随类的卸载而销毁)

🍌static修饰成员方法

静态成员方法也不是某个对象所特有的
可以通过对象调用,也可以通过类名.静态方法名(...)方式调用,更推荐使用后者

注意:
静态方法中不能调用非静态成员变量、非静态成员方法
因为调用非静态成员变量需要使用this来访问;调用非静态成员方法需要传一个this引用,而静态方法中不含this引用

🍌static成员变量初始化

静态成员变量的初始化分为两种:就地初始化静态代码块初始化
那什么是静态代码块呢?往下看~


🍉代码块

使用 {} 定义的一段代码称为代码块根据代码块定义的位置以及关键字,可以分为以下四种:
●普通代码块
●构造块
●静态块
●同步代码块(后续在多线程部分讲解)

🍌普通代码块

定义在方法中的代码块(这种用法较少见)

public class Main{
	public static void main(String[] args) {
		{ //直接使用{}定义,普通方法块
			int x = 10 ;
			System.out.println("x1 = " +x);
		}
		int x = 100 ;
		System.out.println("x2 = " +x);
	}
}

🍌构造代码块

构造代码块,又叫实例代码块。位于成员方法外、类里面,不用加修饰符,一般用于初始化成员变量,所以它只有在创建对象时才会执行

class Student {
    public String name;
    public String sex;
    public int age;
    
    //构造代码块
    {
        this.name = "zhangsan";
        this.sex = "male";
        this.age = 30;
    }
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        System.out.println(student1);
    }
}

在这里插入图片描述

🍌静态块

使用static修饰的代码块称为静态代码块,也是位于成员方法外、类里面,一般用于初始化静态成员变量
比如对于学生类,有一个classroom的静态成员,那就使用静态块进行初始化

    public static String classroom;  //上课的教室
    static {
        classroom = "C-501";
    }

注意:
●不管生成多少个对象,每个静态块都只会执行一次
先执行静态块,然后执行构造块,再执行对应的构造方法
●如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行


🍉继承

面向对象思想中提出了继承的概念,用来提取不同类的共性,实现代码复用
继承允许在保持原有类特性的基础上进行扩展增加新功能,这样产生新的类,称为派生类

例如:狗和猫都是动物,那么我们就可以将共性的内容进行抽取,然后采用继承的思想来达到共用
在这里插入图片描述
在上图中,Dog类和Cat类都继承了Animal类,继承之后,子类可以复用父类中成员,子类在实现时只需关心自己新增加的成员即可

🍌关键字extends

Java中表示类之间的继承关系,需要用到关键字extends

//Animal.java
public class Animal {
    public String name;
    public int age;

    public void eat() {
        System.out.println(name+"在吃饭");
    }

    public void sleep() {
        System.out.println(name+"在睡觉");
    }
}

//Cat.java
public class Cat extends Animal{
    void Catch() {
        System.out.println(name+"在抓老鼠");
    }
}

//Dog.java
public class Dog extends Animal{
    void bark() {
        System.out.println(name+"在汪汪叫");
    }
}

子类会将父类中的成员变量成员方法继承到子类中
注意:被private修饰的成员变量,可以被子类继承,但是不能直接在子类中访问,要访问的话,需要在父类中写一个get方法间接访问

🍌继承关系中的访问

一、访问成员变量

①子类和父类不存在同名的成员变量
直接访问父类从父类继承下来的成员变量

②子类和父类存在同名的成员变量
优先访问子类的成员变量

不管是哪种情况,访问成员变量都遵循就近原则自己有就优先用自己的;如果没有再从父类中找


二、访问成员方法

①成员方法名字不同
成员方法没有同名时,在子类方法中或者通过子类对象访问方法时,优先访问自己的,自己没有时,再到父类中找,如果父类中也没有则报错

public class Base {
	public void methodA(){
		System.out.println("Base中的methodA()方法");
	}
}

public class Derived extends Base{
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		methodB(); // 访问子类自己的methodB()
		methodA(); // 访问父类继承的methodA()
	}
}

②成员方法名字相同
通过子类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用的方法所传递的参数选择合适的方法访问,如果没有则报错

在了解这些访问顺序之后,有这样一个问题:如果子类中存在与父类相同的成员时,那该如何在子类中访问从父类中继承下来的同名的成员呢?
答案是:使用super关键字

🍌关键字super

使用super时需要注意它的使用场景:
●只能在非静态方法中使用
●在子类方法中,要访问父类的成员变量和方法的时候用

(当然,super还有其他用法,后面会讲)

public class Animal {
    public String name;
    public int age;
    public void method() {
        System.out.println("这是父类的method方法");
    }
}

public class Dog extends Animal{
    public String name;
    public int age;
    public String color;

    @Override
    public void method() {  //和父类的method方法构成重写
        System.out.println("这是子类的method方法");
    }
    
    public void method1() {
        method();
        super.method();  //用super访问父类的method方法
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.method1();
    }
}

在这里插入图片描述

🍌子类的构造方法

构造子类对象时,需要先调用父类的构造方法,然后再执行子类的构造方法

子类构造方法中默认会调用父类无参的构造方法,即super()。你没有写的时候编译器会帮你自动添加上去
所以,如果你在父类中写了含参的构造方法,那你在子代构造方法里面就要显式调用super了,因为此时父类中已经没有编译器默认生成的无参构造函数

而且super一定要放在第一句,否则会报错

public class Animal {
    public String name;
    public int age;
    Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
}

public class Dog extends Animal{
    public String color;
    Dog() {
        super("Zhangsan",15);  //显式调用super
        this.color = "white";
    }
}

最后来总结一下super和this的异同之处:
同:
①只能在类的非静态方法中使用,用来访问非静态成员方法和字段;
②在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在

异:
●this是当前对象的引用;super相当于是子类对象中从父类继承下来部分成员的引用

在非静态成员方法中,this用来访问本类的方法和属性;super用来访问父类继承下来的方法和属性
在构造方法中:this(…)用于调用本类构造方法,super(…)用于调用父类构造方法,两种调用不能同时在构造方法中出现
构造方法中一定会存在super(…)的调用,你没有写编译器也会添加;但是this(…)你不写就没有

🍌再谈初始化

再回顾一下上面所说的代码块的执行顺序
静态代码块->实例代码块->构造方法

结合继承关系,那么顺序就是:
父类静态代码块->子类静态代码块->父类实例代码块->父类构造方法->子类的实例代码块->子类构造方法
注意:第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行

🍌继承关系中的访问权限

前面我们认识了四个访问限定符,那么父类中不同访问权限的成员,在子类中的可见性如何呢?
在这里插入图片描述
public和private就不用多说了,它们代表两个极端。父类中public修饰的成员,同个包和不同包中的子类都能访问;而private则都不行
要重点来说的是protected,展示一下不同包中的子类和非子类权限的区别:

//包1
public class Base {
    public int a;
    protected int b;
}

//包2
//不同包中的子类
public class Derived extends Base{
    public void func() {
        super.a = 1;
        super.b = 666;  //正常访问
    }
}

//包3
public class A1 {
    public static void main(String[] args) {
        Base base = new Base();
        base.a = 1;
        base.b = 1;  //报错,因为b在A1中不可见
    }
}

我们了解访问权限是为了能让类尽量做到“封装”,即隐藏内部实现细节,只暴露出必要的信息给类的调用者
因此我们在使用时应尽可能使用比较严格的访问权限。比如:如果一个方法能用 private,就尽量不要用 public

(当然,还有一种简单粗暴的做法:将所有的成员变量都设为 private,将所有的成员方法设为 public。但是这种方式属于滥用权限,不太推荐)
总而言之,写代码的时候要思考这个类提供的成员变量、方法到底给“谁”用的(是类内部自己用,还是类的调用者使用,还是子类使用)

🍌继承方式及关键字final

Java支持单继承多层继承不同类继承同一个类这三种继承方式,如图:


在实际项目中,我们不希望类之间的继承层次太复杂,一般我们不希望出现超过三层的继承关系,如果继承层次太多,就需要考虑对代码进行重构了

如果想从语法上限制继承,可以使用关键字final
final可以用来修饰变量、成员方法以及类

①修饰局部变量或成员变量,表示常量,不能再修改了

final int a = 10;
a = 20; // 编译出错

②修饰类,表示这个类不能被继承
修饰方法,表示该方法不能被重写


🍉组合

和继承类似,组合也是一种表达类之间关系的方式,它也可以实现代码复用。但是组合并没有涉及到特殊的语法(比如 extends 这样的关键字),它是将一个类的对象作为另外一个类的成员变量

关于二者的区别,通俗来说
●继承表示的对象之间是is-a的关系,比如:狗是一种动物(dog is an animal)
●而组合表示对象之间是has-a的关系,比如:汽车有多种零件,汽车和轮胎、发动机、方向盘、车载系统等的关系就是组合,因为汽车是由这些部件组成的

public class Engine {
    //...
}

public class Tire {
    //...
}

public class car {
    private Tire tire; // 可以复用轮胎中的属性和方法
    private Engine engine; // 可以复用发动机中的属性和方法
}

// 奔驰是汽车
public class BenZ extends car{
    // 将汽车中包含的:轮胎、发送机、车载系统全部继承下来
}

●组合相较于继承,整体类与局部类彼此相对独立,不会破坏封装
●而对于继承,由于子类与父类之间紧密耦合,子类依赖于父类的实现,缺乏独立性,所以继承会破坏封装

简而言之就是:能用组合就尽量使用组合

继承要慎用,其使用场合仅限于你确信使用该技术有效的情况。一个判断方法是,问一问自己是否需要从新类向基类进行向上转型。如果是必须的,则继承是必要的。反之则应该好好考虑是否需要继承。——《Java编程思想》
只有当子类真正是超类的子类型时,才适合用继承。换句话说,对于两个类A和B,只有当两者之间确实存在is-a关系的时候,类B才应该继承类A。——《Effective Java》


🍉写在最后

以上就是本篇文章的全部内容,如果你觉得本文对你有所帮助的话,那不妨点个小小的赞哦!(比心)

原文地址:https://blog.csdn.net/Ice_Sugar_7/article/details/135548078

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。

如若转载,请注明出处:http://www.7code.cn/show_56158.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱:suwngjj01@126.com进行投诉反馈,一经查实,立即删除!

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注